Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 3.0.12
4 : *
5 : * This file is not intended to be easily readable and contains a number of
6 : * coding conventions designed to improve portability and efficiency. Do not make
7 : * changes to this file unless you know what you are doing--modify the SWIG
8 : * interface file instead.
9 : * ----------------------------------------------------------------------------- */
10 :
11 : #ifdef _MSC_VER
12 : #define SWIG_PYTHON_INTERPRETER_NO_DEBUG
13 : #else
14 : #define _GNU_SOURCE 1
15 : #endif
16 :
17 :
18 :
19 : #ifndef SWIGPYTHON
20 : #define SWIGPYTHON
21 : #endif
22 :
23 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
24 :
25 : /* -----------------------------------------------------------------------------
26 : * This section contains generic SWIG labels for method/variable
27 : * declarations/attributes, and other compiler dependent labels.
28 : * ----------------------------------------------------------------------------- */
29 :
30 : /* template workaround for compilers that cannot correctly implement the C++ standard */
31 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
32 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
33 : # define SWIGTEMPLATEDISAMBIGUATOR template
34 : # elif defined(__HP_aCC)
35 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
36 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
37 : # define SWIGTEMPLATEDISAMBIGUATOR template
38 : # else
39 : # define SWIGTEMPLATEDISAMBIGUATOR
40 : # endif
41 : #endif
42 :
43 : /* inline attribute */
44 : #ifndef SWIGINLINE
45 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
46 : # define SWIGINLINE inline
47 : # else
48 : # define SWIGINLINE
49 : # endif
50 : #endif
51 :
52 : /* attribute recognised by some compilers to avoid 'unused' warnings */
53 : #ifndef SWIGUNUSED
54 : # if defined(__GNUC__)
55 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
56 : # define SWIGUNUSED __attribute__ ((__unused__))
57 : # else
58 : # define SWIGUNUSED
59 : # endif
60 : # elif defined(__ICC)
61 : # define SWIGUNUSED __attribute__ ((__unused__))
62 : # else
63 : # define SWIGUNUSED
64 : # endif
65 : #endif
66 :
67 : #ifndef SWIG_MSC_UNSUPPRESS_4505
68 : # if defined(_MSC_VER)
69 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
70 : # endif
71 : #endif
72 :
73 : #ifndef SWIGUNUSEDPARM
74 : # ifdef __cplusplus
75 : # define SWIGUNUSEDPARM(p)
76 : # else
77 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
78 : # endif
79 : #endif
80 :
81 : /* internal SWIG method */
82 : #ifndef SWIGINTERN
83 : # define SWIGINTERN static SWIGUNUSED
84 : #endif
85 :
86 : /* internal inline SWIG method */
87 : #ifndef SWIGINTERNINLINE
88 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
89 : #endif
90 :
91 : /* exporting methods */
92 : #if defined(__GNUC__)
93 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
94 : # ifndef GCC_HASCLASSVISIBILITY
95 : # define GCC_HASCLASSVISIBILITY
96 : # endif
97 : # endif
98 : #endif
99 :
100 : #ifndef SWIGEXPORT
101 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
102 : # if defined(STATIC_LINKED)
103 : # define SWIGEXPORT
104 : # else
105 : # define SWIGEXPORT __declspec(dllexport)
106 : # endif
107 : # else
108 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
109 : # define SWIGEXPORT __attribute__ ((visibility("default")))
110 : # else
111 : # define SWIGEXPORT
112 : # endif
113 : # endif
114 : #endif
115 :
116 : /* calling conventions for Windows */
117 : #ifndef SWIGSTDCALL
118 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
119 : # define SWIGSTDCALL __stdcall
120 : # else
121 : # define SWIGSTDCALL
122 : # endif
123 : #endif
124 :
125 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
126 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
127 : # define _CRT_SECURE_NO_DEPRECATE
128 : #endif
129 :
130 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
131 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
132 : # define _SCL_SECURE_NO_DEPRECATE
133 : #endif
134 :
135 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
136 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
137 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
138 : #endif
139 :
140 : /* Intel's compiler complains if a variable which was never initialised is
141 : * cast to void, which is a common idiom which we use to indicate that we
142 : * are aware a variable isn't used. So we just silence that warning.
143 : * See: https://github.com/swig/swig/issues/192 for more discussion.
144 : */
145 : #ifdef __INTEL_COMPILER
146 : # pragma warning disable 592
147 : #endif
148 :
149 :
150 : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
151 : /* Use debug wrappers with the Python release dll */
152 : # undef _DEBUG
153 : # include <Python.h>
154 : # define _DEBUG
155 : #else
156 : # include <Python.h>
157 : #endif
158 :
159 : /* -----------------------------------------------------------------------------
160 : * swigrun.swg
161 : *
162 : * This file contains generic C API SWIG runtime support for pointer
163 : * type checking.
164 : * ----------------------------------------------------------------------------- */
165 :
166 : /* This should only be incremented when either the layout of swig_type_info changes,
167 : or for whatever reason, the runtime changes incompatibly */
168 : #define SWIG_RUNTIME_VERSION "4"
169 :
170 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
171 : #ifdef SWIG_TYPE_TABLE
172 : # define SWIG_QUOTE_STRING(x) #x
173 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
174 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
175 : #else
176 : # define SWIG_TYPE_TABLE_NAME
177 : #endif
178 :
179 : /*
180 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
181 : creating a static or dynamic library from the SWIG runtime code.
182 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
183 :
184 : But only do this if strictly necessary, ie, if you have problems
185 : with your compiler or suchlike.
186 : */
187 :
188 : #ifndef SWIGRUNTIME
189 : # define SWIGRUNTIME SWIGINTERN
190 : #endif
191 :
192 : #ifndef SWIGRUNTIMEINLINE
193 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
194 : #endif
195 :
196 : /* Generic buffer size */
197 : #ifndef SWIG_BUFFER_SIZE
198 : # define SWIG_BUFFER_SIZE 1024
199 : #endif
200 :
201 : /* Flags for pointer conversions */
202 : #define SWIG_POINTER_DISOWN 0x1
203 : #define SWIG_CAST_NEW_MEMORY 0x2
204 :
205 : /* Flags for new pointer objects */
206 : #define SWIG_POINTER_OWN 0x1
207 :
208 :
209 : /*
210 : Flags/methods for returning states.
211 :
212 : The SWIG conversion methods, as ConvertPtr, return an integer
213 : that tells if the conversion was successful or not. And if not,
214 : an error code can be returned (see swigerrors.swg for the codes).
215 :
216 : Use the following macros/flags to set or process the returning
217 : states.
218 :
219 : In old versions of SWIG, code such as the following was usually written:
220 :
221 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
222 : // success code
223 : } else {
224 : //fail code
225 : }
226 :
227 : Now you can be more explicit:
228 :
229 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
230 : if (SWIG_IsOK(res)) {
231 : // success code
232 : } else {
233 : // fail code
234 : }
235 :
236 : which is the same really, but now you can also do
237 :
238 : Type *ptr;
239 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
240 : if (SWIG_IsOK(res)) {
241 : // success code
242 : if (SWIG_IsNewObj(res) {
243 : ...
244 : delete *ptr;
245 : } else {
246 : ...
247 : }
248 : } else {
249 : // fail code
250 : }
251 :
252 : I.e., now SWIG_ConvertPtr can return new objects and you can
253 : identify the case and take care of the deallocation. Of course that
254 : also requires SWIG_ConvertPtr to return new result values, such as
255 :
256 : int SWIG_ConvertPtr(obj, ptr,...) {
257 : if (<obj is ok>) {
258 : if (<need new object>) {
259 : *ptr = <ptr to new allocated object>;
260 : return SWIG_NEWOBJ;
261 : } else {
262 : *ptr = <ptr to old object>;
263 : return SWIG_OLDOBJ;
264 : }
265 : } else {
266 : return SWIG_BADOBJ;
267 : }
268 : }
269 :
270 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
271 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
272 : SWIG errors code.
273 :
274 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
275 : allows to return the 'cast rank', for example, if you have this
276 :
277 : int food(double)
278 : int fooi(int);
279 :
280 : and you call
281 :
282 : food(1) // cast rank '1' (1 -> 1.0)
283 : fooi(1) // cast rank '0'
284 :
285 : just use the SWIG_AddCast()/SWIG_CheckState()
286 : */
287 :
288 : #define SWIG_OK (0)
289 : #define SWIG_ERROR (-1)
290 : #define SWIG_IsOK(r) (r >= 0)
291 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
292 :
293 : /* The CastRankLimit says how many bits are used for the cast rank */
294 : #define SWIG_CASTRANKLIMIT (1 << 8)
295 : /* The NewMask denotes the object was created (using new/malloc) */
296 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
297 : /* The TmpMask is for in/out typemaps that use temporal objects */
298 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
299 : /* Simple returning values */
300 : #define SWIG_BADOBJ (SWIG_ERROR)
301 : #define SWIG_OLDOBJ (SWIG_OK)
302 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
303 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
304 : /* Check, add and del mask methods */
305 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
306 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
307 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
308 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
309 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
310 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
311 :
312 : /* Cast-Rank Mode */
313 : #if defined(SWIG_CASTRANK_MODE)
314 : # ifndef SWIG_TypeRank
315 : # define SWIG_TypeRank unsigned long
316 : # endif
317 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
318 : # define SWIG_MAXCASTRANK (2)
319 : # endif
320 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
321 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
322 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
323 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
324 : }
325 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
326 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
327 : }
328 : #else /* no cast-rank mode */
329 : # define SWIG_AddCast(r) (r)
330 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
331 : #endif
332 :
333 :
334 : #include <string.h>
335 :
336 : #ifdef __cplusplus
337 : extern "C" {
338 : #endif
339 :
340 : typedef void *(*swig_converter_func)(void *, int *);
341 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
342 :
343 : /* Structure to store information on one type */
344 : typedef struct swig_type_info {
345 : const char *name; /* mangled name of this type */
346 : const char *str; /* human readable name of this type */
347 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
348 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
349 : void *clientdata; /* language specific type data */
350 : int owndata; /* flag if the structure owns the clientdata */
351 : } swig_type_info;
352 :
353 : /* Structure to store a type and conversion function used for casting */
354 : typedef struct swig_cast_info {
355 : swig_type_info *type; /* pointer to type that is equivalent to this type */
356 : swig_converter_func converter; /* function to cast the void pointers */
357 : struct swig_cast_info *next; /* pointer to next cast in linked list */
358 : struct swig_cast_info *prev; /* pointer to the previous cast */
359 : } swig_cast_info;
360 :
361 : /* Structure used to store module information
362 : * Each module generates one structure like this, and the runtime collects
363 : * all of these structures and stores them in a circularly linked list.*/
364 : typedef struct swig_module_info {
365 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
366 : size_t size; /* Number of types in this module */
367 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
368 : swig_type_info **type_initial; /* Array of initially generated type structures */
369 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
370 : void *clientdata; /* Language specific module data */
371 : } swig_module_info;
372 :
373 : /*
374 : Compare two type names skipping the space characters, therefore
375 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
376 :
377 : Return 0 when the two name types are equivalent, as in
378 : strncmp, but skipping ' '.
379 : */
380 : SWIGRUNTIME int
381 0 : SWIG_TypeNameComp(const char *f1, const char *l1,
382 : const char *f2, const char *l2) {
383 0 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
384 0 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
385 0 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
386 0 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
387 : }
388 0 : return (int)((l1 - f1) - (l2 - f2));
389 : }
390 :
391 : /*
392 : Check type equivalence in a name list like <name1>|<name2>|...
393 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
394 : */
395 : SWIGRUNTIME int
396 0 : SWIG_TypeCmp(const char *nb, const char *tb) {
397 : int equiv = 1;
398 0 : const char* te = tb + strlen(tb);
399 : const char* ne = nb;
400 0 : while (equiv != 0 && *ne) {
401 0 : for (nb = ne; *ne; ++ne) {
402 0 : if (*ne == '|') break;
403 : }
404 0 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
405 0 : if (*ne) ++ne;
406 : }
407 0 : return equiv;
408 : }
409 :
410 : /*
411 : Check type equivalence in a name list like <name1>|<name2>|...
412 : Return 0 if not equal, 1 if equal
413 : */
414 : SWIGRUNTIME int
415 : SWIG_TypeEquiv(const char *nb, const char *tb) {
416 0 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
417 : }
418 :
419 : /*
420 : Check the typename
421 : */
422 : SWIGRUNTIME swig_cast_info *
423 0 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
424 0 : if (ty) {
425 0 : swig_cast_info *iter = ty->cast;
426 0 : while (iter) {
427 0 : if (strcmp(iter->type->name, c) == 0) {
428 0 : if (iter == ty->cast)
429 : return iter;
430 : /* Move iter to the top of the linked list */
431 0 : iter->prev->next = iter->next;
432 0 : if (iter->next)
433 0 : iter->next->prev = iter->prev;
434 0 : iter->next = ty->cast;
435 0 : iter->prev = 0;
436 0 : if (ty->cast) ty->cast->prev = iter;
437 0 : ty->cast = iter;
438 0 : return iter;
439 : }
440 0 : iter = iter->next;
441 : }
442 : }
443 : return 0;
444 : }
445 :
446 : /*
447 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
448 : */
449 : SWIGRUNTIME swig_cast_info *
450 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
451 : if (ty) {
452 : swig_cast_info *iter = ty->cast;
453 : while (iter) {
454 : if (iter->type == from) {
455 : if (iter == ty->cast)
456 : return iter;
457 : /* Move iter to the top of the linked list */
458 : iter->prev->next = iter->next;
459 : if (iter->next)
460 : iter->next->prev = iter->prev;
461 : iter->next = ty->cast;
462 : iter->prev = 0;
463 : if (ty->cast) ty->cast->prev = iter;
464 : ty->cast = iter;
465 : return iter;
466 : }
467 : iter = iter->next;
468 : }
469 : }
470 : return 0;
471 : }
472 :
473 : /*
474 : Cast a pointer up an inheritance hierarchy
475 : */
476 : SWIGRUNTIMEINLINE void *
477 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
478 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
479 : }
480 :
481 : /*
482 : Dynamic pointer casting. Down an inheritance hierarchy
483 : */
484 : SWIGRUNTIME swig_type_info *
485 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
486 : swig_type_info *lastty = ty;
487 : if (!ty || !ty->dcast) return ty;
488 : while (ty && (ty->dcast)) {
489 : ty = (*ty->dcast)(ptr);
490 : if (ty) lastty = ty;
491 : }
492 : return lastty;
493 : }
494 :
495 : /*
496 : Return the name associated with this type
497 : */
498 : SWIGRUNTIMEINLINE const char *
499 : SWIG_TypeName(const swig_type_info *ty) {
500 : return ty->name;
501 : }
502 :
503 : /*
504 : Return the pretty name associated with this type,
505 : that is an unmangled type name in a form presentable to the user.
506 : */
507 : SWIGRUNTIME const char *
508 : SWIG_TypePrettyName(const swig_type_info *type) {
509 : /* The "str" field contains the equivalent pretty names of the
510 : type, separated by vertical-bar characters. We choose
511 : to print the last name, as it is often (?) the most
512 : specific. */
513 1 : if (!type) return NULL;
514 1 : if (type->str != NULL) {
515 : const char *last_name = type->str;
516 : const char *s;
517 1 : for (s = type->str; *s; s++)
518 1 : if (*s == '|') last_name = s+1;
519 : return last_name;
520 : }
521 : else
522 0 : return type->name;
523 : }
524 :
525 : /*
526 : Set the clientdata field for a type
527 : */
528 : SWIGRUNTIME void
529 1 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
530 1 : swig_cast_info *cast = ti->cast;
531 : /* if (ti->clientdata == clientdata) return; */
532 1 : ti->clientdata = clientdata;
533 :
534 1 : while (cast) {
535 1 : if (!cast->converter) {
536 1 : swig_type_info *tc = cast->type;
537 1 : if (!tc->clientdata) {
538 0 : SWIG_TypeClientData(tc, clientdata);
539 : }
540 : }
541 1 : cast = cast->next;
542 : }
543 1 : }
544 : SWIGRUNTIME void
545 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
546 1 : SWIG_TypeClientData(ti, clientdata);
547 1 : ti->owndata = 1;
548 : }
549 :
550 : /*
551 : Search for a swig_type_info structure only by mangled name
552 : Search is a O(log #types)
553 :
554 : We start searching at module start, and finish searching when start == end.
555 : Note: if start == end at the beginning of the function, we go all the way around
556 : the circular list.
557 : */
558 : SWIGRUNTIME swig_type_info *
559 1 : SWIG_MangledTypeQueryModule(swig_module_info *start,
560 : swig_module_info *end,
561 : const char *name) {
562 : swig_module_info *iter = start;
563 : do {
564 1 : if (iter->size) {
565 : size_t l = 0;
566 1 : size_t r = iter->size - 1;
567 : do {
568 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
569 1 : size_t i = (l + r) >> 1;
570 1 : const char *iname = iter->types[i]->name;
571 1 : if (iname) {
572 1 : int compare = strcmp(name, iname);
573 1 : if (compare == 0) {
574 : return iter->types[i];
575 1 : } else if (compare < 0) {
576 1 : if (i) {
577 1 : r = i - 1;
578 : } else {
579 : break;
580 : }
581 : } else if (compare > 0) {
582 1 : l = i + 1;
583 : }
584 : } else {
585 : break; /* should never happen */
586 : }
587 1 : } while (l <= r);
588 : }
589 0 : iter = iter->next;
590 0 : } while (iter != end);
591 : return 0;
592 : }
593 :
594 : /*
595 : Search for a swig_type_info structure for either a mangled name or a human readable name.
596 : It first searches the mangled names of the types, which is a O(log #types)
597 : If a type is not found it then searches the human readable names, which is O(#types).
598 :
599 : We start searching at module start, and finish searching when start == end.
600 : Note: if start == end at the beginning of the function, we go all the way around
601 : the circular list.
602 : */
603 : SWIGRUNTIME swig_type_info *
604 1 : SWIG_TypeQueryModule(swig_module_info *start,
605 : swig_module_info *end,
606 : const char *name) {
607 : /* STEP 1: Search the name field using binary search */
608 1 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
609 1 : if (ret) {
610 : return ret;
611 : } else {
612 : /* STEP 2: If the type hasn't been found, do a complete search
613 : of the str field (the human readable name) */
614 : swig_module_info *iter = start;
615 : do {
616 : size_t i = 0;
617 0 : for (; i < iter->size; ++i) {
618 0 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
619 : return iter->types[i];
620 : }
621 0 : iter = iter->next;
622 0 : } while (iter != end);
623 : }
624 :
625 : /* neither found a match */
626 : return 0;
627 : }
628 :
629 : /*
630 : Pack binary data into a string
631 : */
632 : SWIGRUNTIME char *
633 : SWIG_PackData(char *c, void *ptr, size_t sz) {
634 : static const char hex[17] = "0123456789abcdef";
635 : const unsigned char *u = (unsigned char *) ptr;
636 0 : const unsigned char *eu = u + sz;
637 0 : for (; u != eu; ++u) {
638 0 : unsigned char uu = *u;
639 0 : *(c++) = hex[(uu & 0xf0) >> 4];
640 0 : *(c++) = hex[uu & 0xf];
641 : }
642 : return c;
643 : }
644 :
645 : /*
646 : Unpack binary data from a string
647 : */
648 : SWIGRUNTIME const char *
649 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
650 : unsigned char *u = (unsigned char *) ptr;
651 : const unsigned char *eu = u + sz;
652 : for (; u != eu; ++u) {
653 : char d = *(c++);
654 : unsigned char uu;
655 : if ((d >= '0') && (d <= '9'))
656 : uu = (unsigned char)((d - '0') << 4);
657 : else if ((d >= 'a') && (d <= 'f'))
658 : uu = (unsigned char)((d - ('a'-10)) << 4);
659 : else
660 : return (char *) 0;
661 : d = *(c++);
662 : if ((d >= '0') && (d <= '9'))
663 : uu |= (unsigned char)(d - '0');
664 : else if ((d >= 'a') && (d <= 'f'))
665 : uu |= (unsigned char)(d - ('a'-10));
666 : else
667 : return (char *) 0;
668 : *u = uu;
669 : }
670 : return c;
671 : }
672 :
673 : /*
674 : Pack 'void *' into a string buffer.
675 : */
676 : SWIGRUNTIME char *
677 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
678 : char *r = buff;
679 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
680 0 : *(r++) = '_';
681 : r = SWIG_PackData(r,&ptr,sizeof(void *));
682 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
683 : strcpy(r,name);
684 0 : return buff;
685 : }
686 :
687 : SWIGRUNTIME const char *
688 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
689 : if (*c != '_') {
690 : if (strcmp(c,"NULL") == 0) {
691 : *ptr = (void *) 0;
692 : return name;
693 : } else {
694 : return 0;
695 : }
696 : }
697 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
698 : }
699 :
700 : SWIGRUNTIME char *
701 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
702 : char *r = buff;
703 0 : size_t lname = (name ? strlen(name) : 0);
704 0 : if ((2*sz + 2 + lname) > bsz) return 0;
705 0 : *(r++) = '_';
706 : r = SWIG_PackData(r,ptr,sz);
707 0 : if (lname) {
708 0 : strncpy(r,name,lname+1);
709 : } else {
710 0 : *r = 0;
711 : }
712 : return buff;
713 : }
714 :
715 : SWIGRUNTIME const char *
716 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
717 : if (*c != '_') {
718 : if (strcmp(c,"NULL") == 0) {
719 : memset(ptr,0,sz);
720 : return name;
721 : } else {
722 : return 0;
723 : }
724 : }
725 : return SWIG_UnpackData(++c,ptr,sz);
726 : }
727 :
728 : #ifdef __cplusplus
729 : }
730 : #endif
731 :
732 : /* Errors in SWIG */
733 : #define SWIG_UnknownError -1
734 : #define SWIG_IOError -2
735 : #define SWIG_RuntimeError -3
736 : #define SWIG_IndexError -4
737 : #define SWIG_TypeError -5
738 : #define SWIG_DivisionByZero -6
739 : #define SWIG_OverflowError -7
740 : #define SWIG_SyntaxError -8
741 : #define SWIG_ValueError -9
742 : #define SWIG_SystemError -10
743 : #define SWIG_AttributeError -11
744 : #define SWIG_MemoryError -12
745 : #define SWIG_NullReferenceError -13
746 :
747 :
748 :
749 : /* Compatibility macros for Python 3 */
750 : #if PY_VERSION_HEX >= 0x03000000
751 :
752 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
753 : #define PyInt_Check(x) PyLong_Check(x)
754 : #define PyInt_AsLong(x) PyLong_AsLong(x)
755 : #define PyInt_FromLong(x) PyLong_FromLong(x)
756 : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
757 : #define PyString_Check(name) PyBytes_Check(name)
758 : #define PyString_FromString(x) PyUnicode_FromString(x)
759 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
760 : #define PyString_AsString(str) PyBytes_AsString(str)
761 : #define PyString_Size(str) PyBytes_Size(str)
762 : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
763 : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
764 : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
765 : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
766 :
767 : #endif
768 :
769 : #ifndef Py_TYPE
770 : # define Py_TYPE(op) ((op)->ob_type)
771 : #endif
772 :
773 : /* SWIG APIs for compatibility of both Python 2 & 3 */
774 :
775 : #if PY_VERSION_HEX >= 0x03000000
776 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
777 : #else
778 : # define SWIG_Python_str_FromFormat PyString_FromFormat
779 : #endif
780 :
781 :
782 : /* Warning: This function will allocate a new string in Python 3,
783 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
784 : */
785 : SWIGINTERN char*
786 : SWIG_Python_str_AsChar(PyObject *str)
787 : {
788 : #if PY_VERSION_HEX >= 0x03000000
789 : char *cstr;
790 : char *newstr;
791 : Py_ssize_t len;
792 : str = PyUnicode_AsUTF8String(str);
793 : PyBytes_AsStringAndSize(str, &cstr, &len);
794 : newstr = (char *) malloc(len+1);
795 : memcpy(newstr, cstr, len+1);
796 : Py_XDECREF(str);
797 : return newstr;
798 : #else
799 : return PyString_AsString(str);
800 : #endif
801 : }
802 :
803 : #if PY_VERSION_HEX >= 0x03000000
804 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
805 : #else
806 : # define SWIG_Python_str_DelForPy3(x)
807 : #endif
808 :
809 :
810 : SWIGINTERN PyObject*
811 : SWIG_Python_str_FromChar(const char *c)
812 : {
813 : #if PY_VERSION_HEX >= 0x03000000
814 1 : return PyUnicode_FromString(c);
815 : #else
816 : return PyString_FromString(c);
817 : #endif
818 : }
819 :
820 : /* Add PyOS_snprintf for old Pythons */
821 : #if PY_VERSION_HEX < 0x02020000
822 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
823 : # define PyOS_snprintf _snprintf
824 : # else
825 : # define PyOS_snprintf snprintf
826 : # endif
827 : #endif
828 :
829 : /* A crude PyString_FromFormat implementation for old Pythons */
830 : #if PY_VERSION_HEX < 0x02020000
831 :
832 : #ifndef SWIG_PYBUFFER_SIZE
833 : # define SWIG_PYBUFFER_SIZE 1024
834 : #endif
835 :
836 : static PyObject *
837 : PyString_FromFormat(const char *fmt, ...) {
838 : va_list ap;
839 : char buf[SWIG_PYBUFFER_SIZE * 2];
840 : int res;
841 : va_start(ap, fmt);
842 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
843 : va_end(ap);
844 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
845 : }
846 : #endif
847 :
848 : #ifndef PyObject_DEL
849 : # define PyObject_DEL PyObject_Del
850 : #endif
851 :
852 : /* A crude PyExc_StopIteration exception for old Pythons */
853 : #if PY_VERSION_HEX < 0x02020000
854 : # ifndef PyExc_StopIteration
855 : # define PyExc_StopIteration PyExc_RuntimeError
856 : # endif
857 : # ifndef PyObject_GenericGetAttr
858 : # define PyObject_GenericGetAttr 0
859 : # endif
860 : #endif
861 :
862 : /* Py_NotImplemented is defined in 2.1 and up. */
863 : #if PY_VERSION_HEX < 0x02010000
864 : # ifndef Py_NotImplemented
865 : # define Py_NotImplemented PyExc_RuntimeError
866 : # endif
867 : #endif
868 :
869 : /* A crude PyString_AsStringAndSize implementation for old Pythons */
870 : #if PY_VERSION_HEX < 0x02010000
871 : # ifndef PyString_AsStringAndSize
872 : # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
873 : # endif
874 : #endif
875 :
876 : /* PySequence_Size for old Pythons */
877 : #if PY_VERSION_HEX < 0x02000000
878 : # ifndef PySequence_Size
879 : # define PySequence_Size PySequence_Length
880 : # endif
881 : #endif
882 :
883 : /* PyBool_FromLong for old Pythons */
884 : #if PY_VERSION_HEX < 0x02030000
885 : static
886 : PyObject *PyBool_FromLong(long ok)
887 : {
888 : PyObject *result = ok ? Py_True : Py_False;
889 : Py_INCREF(result);
890 : return result;
891 : }
892 : #endif
893 :
894 : /* Py_ssize_t for old Pythons */
895 : /* This code is as recommended by: */
896 : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
897 : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
898 : typedef int Py_ssize_t;
899 : # define PY_SSIZE_T_MAX INT_MAX
900 : # define PY_SSIZE_T_MIN INT_MIN
901 : typedef inquiry lenfunc;
902 : typedef intargfunc ssizeargfunc;
903 : typedef intintargfunc ssizessizeargfunc;
904 : typedef intobjargproc ssizeobjargproc;
905 : typedef intintobjargproc ssizessizeobjargproc;
906 : typedef getreadbufferproc readbufferproc;
907 : typedef getwritebufferproc writebufferproc;
908 : typedef getsegcountproc segcountproc;
909 : typedef getcharbufferproc charbufferproc;
910 : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
911 : {
912 : long result = 0;
913 : PyObject *i = PyNumber_Int(x);
914 : if (i) {
915 : result = PyInt_AsLong(i);
916 : Py_DECREF(i);
917 : }
918 : return result;
919 : }
920 : #endif
921 :
922 : #if PY_VERSION_HEX < 0x02050000
923 : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
924 : #endif
925 :
926 : #if PY_VERSION_HEX < 0x02040000
927 : #define Py_VISIT(op) \
928 : do { \
929 : if (op) { \
930 : int vret = visit((op), arg); \
931 : if (vret) \
932 : return vret; \
933 : } \
934 : } while (0)
935 : #endif
936 :
937 : #if PY_VERSION_HEX < 0x02030000
938 : typedef struct {
939 : PyTypeObject type;
940 : PyNumberMethods as_number;
941 : PyMappingMethods as_mapping;
942 : PySequenceMethods as_sequence;
943 : PyBufferProcs as_buffer;
944 : PyObject *name, *slots;
945 : } PyHeapTypeObject;
946 : #endif
947 :
948 : #if PY_VERSION_HEX < 0x02030000
949 : typedef destructor freefunc;
950 : #endif
951 :
952 : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
953 : (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
954 : (PY_MAJOR_VERSION > 3))
955 : # define SWIGPY_USE_CAPSULE
956 : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
957 : #endif
958 :
959 : #if PY_VERSION_HEX < 0x03020000
960 : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
961 : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
962 : #define Py_hash_t long
963 : #endif
964 :
965 : /* -----------------------------------------------------------------------------
966 : * error manipulation
967 : * ----------------------------------------------------------------------------- */
968 :
969 : SWIGRUNTIME PyObject*
970 0 : SWIG_Python_ErrorType(int code) {
971 : PyObject* type = 0;
972 0 : switch(code) {
973 0 : case SWIG_MemoryError:
974 0 : type = PyExc_MemoryError;
975 0 : break;
976 0 : case SWIG_IOError:
977 0 : type = PyExc_IOError;
978 0 : break;
979 0 : case SWIG_RuntimeError:
980 0 : type = PyExc_RuntimeError;
981 0 : break;
982 0 : case SWIG_IndexError:
983 0 : type = PyExc_IndexError;
984 0 : break;
985 0 : case SWIG_TypeError:
986 0 : type = PyExc_TypeError;
987 0 : break;
988 0 : case SWIG_DivisionByZero:
989 0 : type = PyExc_ZeroDivisionError;
990 0 : break;
991 0 : case SWIG_OverflowError:
992 0 : type = PyExc_OverflowError;
993 0 : break;
994 0 : case SWIG_SyntaxError:
995 0 : type = PyExc_SyntaxError;
996 0 : break;
997 0 : case SWIG_ValueError:
998 0 : type = PyExc_ValueError;
999 0 : break;
1000 0 : case SWIG_SystemError:
1001 0 : type = PyExc_SystemError;
1002 0 : break;
1003 0 : case SWIG_AttributeError:
1004 0 : type = PyExc_AttributeError;
1005 0 : break;
1006 0 : default:
1007 0 : type = PyExc_RuntimeError;
1008 : }
1009 0 : return type;
1010 : }
1011 :
1012 :
1013 : SWIGRUNTIME void
1014 : SWIG_Python_AddErrorMsg(const char* mesg)
1015 : {
1016 : PyObject *type = 0;
1017 : PyObject *value = 0;
1018 : PyObject *traceback = 0;
1019 :
1020 : if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1021 : if (value) {
1022 : char *tmp;
1023 : PyObject *old_str = PyObject_Str(value);
1024 : PyErr_Clear();
1025 : Py_XINCREF(type);
1026 :
1027 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1028 : SWIG_Python_str_DelForPy3(tmp);
1029 : Py_DECREF(old_str);
1030 : Py_DECREF(value);
1031 : } else {
1032 : PyErr_SetString(PyExc_RuntimeError, mesg);
1033 : }
1034 : }
1035 :
1036 : #if defined(SWIG_PYTHON_NO_THREADS)
1037 : # if defined(SWIG_PYTHON_THREADS)
1038 : # undef SWIG_PYTHON_THREADS
1039 : # endif
1040 : #endif
1041 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1042 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1043 : # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1044 : # define SWIG_PYTHON_USE_GIL
1045 : # endif
1046 : # endif
1047 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1048 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1049 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1050 : # endif
1051 : # ifdef __cplusplus /* C++ code */
1052 : class SWIG_Python_Thread_Block {
1053 : bool status;
1054 : PyGILState_STATE state;
1055 : public:
1056 : void end() { if (status) { PyGILState_Release(state); status = false;} }
1057 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1058 : ~SWIG_Python_Thread_Block() { end(); }
1059 : };
1060 : class SWIG_Python_Thread_Allow {
1061 : bool status;
1062 : PyThreadState *save;
1063 : public:
1064 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1065 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1066 : ~SWIG_Python_Thread_Allow() { end(); }
1067 : };
1068 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1069 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1070 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1071 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1072 : # else /* C code */
1073 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1074 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1075 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1076 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1077 : # endif
1078 : # else /* Old thread way, not implemented, user must provide it */
1079 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1080 : # define SWIG_PYTHON_INITIALIZE_THREADS
1081 : # endif
1082 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1083 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1084 : # endif
1085 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1086 : # define SWIG_PYTHON_THREAD_END_BLOCK
1087 : # endif
1088 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1089 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1090 : # endif
1091 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1092 : # define SWIG_PYTHON_THREAD_END_ALLOW
1093 : # endif
1094 : # endif
1095 : #else /* No thread support */
1096 : # define SWIG_PYTHON_INITIALIZE_THREADS
1097 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1098 : # define SWIG_PYTHON_THREAD_END_BLOCK
1099 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1100 : # define SWIG_PYTHON_THREAD_END_ALLOW
1101 : #endif
1102 :
1103 : /* -----------------------------------------------------------------------------
1104 : * Python API portion that goes into the runtime
1105 : * ----------------------------------------------------------------------------- */
1106 :
1107 : #ifdef __cplusplus
1108 : extern "C" {
1109 : #endif
1110 :
1111 : /* -----------------------------------------------------------------------------
1112 : * Constant declarations
1113 : * ----------------------------------------------------------------------------- */
1114 :
1115 : /* Constant Types */
1116 : #define SWIG_PY_POINTER 4
1117 : #define SWIG_PY_BINARY 5
1118 :
1119 : /* Constant information structure */
1120 : typedef struct swig_const_info {
1121 : int type;
1122 : char *name;
1123 : long lvalue;
1124 : double dvalue;
1125 : void *pvalue;
1126 : swig_type_info **ptype;
1127 : } swig_const_info;
1128 :
1129 :
1130 : /* -----------------------------------------------------------------------------
1131 : * Wrapper of PyInstanceMethod_New() used in Python 3
1132 : * It is exported to the generated module, used for -fastproxy
1133 : * ----------------------------------------------------------------------------- */
1134 : #if PY_VERSION_HEX >= 0x03000000
1135 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1136 : {
1137 0 : return PyInstanceMethod_New(func);
1138 : }
1139 : #else
1140 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1141 : {
1142 : return NULL;
1143 : }
1144 : #endif
1145 :
1146 : #ifdef __cplusplus
1147 : }
1148 : #endif
1149 :
1150 :
1151 : /* -----------------------------------------------------------------------------
1152 : * pyrun.swg
1153 : *
1154 : * This file contains the runtime support for Python modules
1155 : * and includes code for managing global variables and pointer
1156 : * type checking.
1157 : *
1158 : * ----------------------------------------------------------------------------- */
1159 :
1160 : /* Common SWIG API */
1161 :
1162 : /* for raw pointers */
1163 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1164 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1165 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1166 :
1167 : #ifdef SWIGPYTHON_BUILTIN
1168 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1169 : #else
1170 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1171 : #endif
1172 :
1173 : #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1174 :
1175 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1176 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1177 : #define swig_owntype int
1178 :
1179 : /* for raw packed data */
1180 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1181 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1182 :
1183 : /* for class or struct pointers */
1184 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1185 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1186 :
1187 : /* for C or C++ function pointers */
1188 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1189 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1190 :
1191 : /* for C++ member pointers, ie, member methods */
1192 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1193 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1194 :
1195 :
1196 : /* Runtime API */
1197 :
1198 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1199 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1200 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1201 :
1202 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1203 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1204 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1205 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1206 : #define SWIG_fail goto fail
1207 :
1208 :
1209 : /* Runtime API implementation */
1210 :
1211 : /* Error manipulation */
1212 :
1213 : SWIGINTERN void
1214 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1215 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1216 : PyErr_SetObject(errtype, obj);
1217 : Py_DECREF(obj);
1218 : SWIG_PYTHON_THREAD_END_BLOCK;
1219 : }
1220 :
1221 : SWIGINTERN void
1222 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1223 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1224 0 : PyErr_SetString(errtype, msg);
1225 : SWIG_PYTHON_THREAD_END_BLOCK;
1226 : }
1227 :
1228 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1229 :
1230 : /* Set a constant value */
1231 :
1232 : #if defined(SWIGPYTHON_BUILTIN)
1233 :
1234 : SWIGINTERN void
1235 : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1236 : PyObject *s = PyString_InternFromString(key);
1237 : PyList_Append(seq, s);
1238 : Py_DECREF(s);
1239 : }
1240 :
1241 : SWIGINTERN void
1242 : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1243 : #if PY_VERSION_HEX < 0x02030000
1244 : PyDict_SetItemString(d, (char *)name, obj);
1245 : #else
1246 : PyDict_SetItemString(d, name, obj);
1247 : #endif
1248 : Py_DECREF(obj);
1249 : if (public_interface)
1250 : SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1251 : }
1252 :
1253 : #else
1254 :
1255 : SWIGINTERN void
1256 1 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1257 : #if PY_VERSION_HEX < 0x02030000
1258 : PyDict_SetItemString(d, (char *)name, obj);
1259 : #else
1260 1 : PyDict_SetItemString(d, name, obj);
1261 : #endif
1262 1 : Py_DECREF(obj);
1263 1 : }
1264 :
1265 : #endif
1266 :
1267 : /* Append a value to the result obj */
1268 :
1269 : SWIGINTERN PyObject*
1270 1 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1271 : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1272 1 : if (!result) {
1273 : result = obj;
1274 1 : } else if (result == Py_None) {
1275 1 : Py_DECREF(result);
1276 : result = obj;
1277 : } else {
1278 0 : if (!PyList_Check(result)) {
1279 : PyObject *o2 = result;
1280 0 : result = PyList_New(1);
1281 0 : PyList_SetItem(result, 0, o2);
1282 : }
1283 0 : PyList_Append(result,obj);
1284 0 : Py_DECREF(obj);
1285 : }
1286 1 : return result;
1287 : #else
1288 : PyObject* o2;
1289 : PyObject* o3;
1290 : if (!result) {
1291 : result = obj;
1292 : } else if (result == Py_None) {
1293 : Py_DECREF(result);
1294 : result = obj;
1295 : } else {
1296 : if (!PyTuple_Check(result)) {
1297 : o2 = result;
1298 : result = PyTuple_New(1);
1299 : PyTuple_SET_ITEM(result, 0, o2);
1300 : }
1301 : o3 = PyTuple_New(1);
1302 : PyTuple_SET_ITEM(o3, 0, obj);
1303 : o2 = result;
1304 : result = PySequence_Concat(o2, o3);
1305 : Py_DECREF(o2);
1306 : Py_DECREF(o3);
1307 : }
1308 : return result;
1309 : #endif
1310 : }
1311 :
1312 : /* Unpack the argument tuple */
1313 :
1314 : SWIGINTERN Py_ssize_t
1315 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1316 : {
1317 : if (!args) {
1318 : if (!min && !max) {
1319 : return 1;
1320 : } else {
1321 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1322 : name, (min == max ? "" : "at least "), (int)min);
1323 : return 0;
1324 : }
1325 : }
1326 : if (!PyTuple_Check(args)) {
1327 : if (min <= 1 && max >= 1) {
1328 : Py_ssize_t i;
1329 : objs[0] = args;
1330 : for (i = 1; i < max; ++i) {
1331 : objs[i] = 0;
1332 : }
1333 : return 2;
1334 : }
1335 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1336 : return 0;
1337 : } else {
1338 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1339 : if (l < min) {
1340 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1341 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1342 : return 0;
1343 : } else if (l > max) {
1344 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1345 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1346 : return 0;
1347 : } else {
1348 : Py_ssize_t i;
1349 : for (i = 0; i < l; ++i) {
1350 : objs[i] = PyTuple_GET_ITEM(args, i);
1351 : }
1352 : for (; l < max; ++l) {
1353 : objs[l] = 0;
1354 : }
1355 : return i + 1;
1356 : }
1357 : }
1358 : }
1359 :
1360 : /* A functor is a function object with one single object argument */
1361 : #if PY_VERSION_HEX >= 0x02020000
1362 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1363 : #else
1364 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1365 : #endif
1366 :
1367 : /*
1368 : Helper for static pointer initialization for both C and C++ code, for example
1369 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1370 : */
1371 : #ifdef __cplusplus
1372 : #define SWIG_STATIC_POINTER(var) var
1373 : #else
1374 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1375 : #endif
1376 :
1377 : /* -----------------------------------------------------------------------------
1378 : * Pointer declarations
1379 : * ----------------------------------------------------------------------------- */
1380 :
1381 : /* Flags for new pointer objects */
1382 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1383 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1384 :
1385 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1386 :
1387 : #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1388 : #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1389 :
1390 : #ifdef __cplusplus
1391 : extern "C" {
1392 : #endif
1393 :
1394 : /* How to access Py_None */
1395 : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1396 : # ifndef SWIG_PYTHON_NO_BUILD_NONE
1397 : # ifndef SWIG_PYTHON_BUILD_NONE
1398 : # define SWIG_PYTHON_BUILD_NONE
1399 : # endif
1400 : # endif
1401 : #endif
1402 :
1403 : #ifdef SWIG_PYTHON_BUILD_NONE
1404 : # ifdef Py_None
1405 : # undef Py_None
1406 : # define Py_None SWIG_Py_None()
1407 : # endif
1408 : SWIGRUNTIMEINLINE PyObject *
1409 : _SWIG_Py_None(void)
1410 : {
1411 : PyObject *none = Py_BuildValue((char*)"");
1412 : Py_DECREF(none);
1413 : return none;
1414 : }
1415 : SWIGRUNTIME PyObject *
1416 : SWIG_Py_None(void)
1417 : {
1418 : static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1419 : return none;
1420 : }
1421 : #endif
1422 :
1423 : /* The python void return value */
1424 :
1425 : SWIGRUNTIMEINLINE PyObject *
1426 : SWIG_Py_Void(void)
1427 : {
1428 : PyObject *none = Py_None;
1429 1 : Py_INCREF(none);
1430 : return none;
1431 : }
1432 :
1433 : /* SwigPyClientData */
1434 :
1435 : typedef struct {
1436 : PyObject *klass;
1437 : PyObject *newraw;
1438 : PyObject *newargs;
1439 : PyObject *destroy;
1440 : int delargs;
1441 : int implicitconv;
1442 : PyTypeObject *pytype;
1443 : } SwigPyClientData;
1444 :
1445 : SWIGRUNTIMEINLINE int
1446 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1447 : {
1448 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1449 : return data ? data->implicitconv : 0;
1450 : }
1451 :
1452 : SWIGRUNTIMEINLINE PyObject *
1453 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1454 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1455 : PyObject *klass = data ? data->klass : 0;
1456 : return (klass ? klass : PyExc_RuntimeError);
1457 : }
1458 :
1459 :
1460 : SWIGRUNTIME SwigPyClientData *
1461 1 : SwigPyClientData_New(PyObject* obj)
1462 : {
1463 1 : if (!obj) {
1464 : return 0;
1465 : } else {
1466 1 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1467 : /* the klass element */
1468 1 : data->klass = obj;
1469 1 : Py_INCREF(data->klass);
1470 : /* the newraw method and newargs arguments used to create a new raw instance */
1471 1 : if (PyClass_Check(obj)) {
1472 1 : data->newraw = 0;
1473 1 : data->newargs = obj;
1474 1 : Py_INCREF(obj);
1475 : } else {
1476 : #if (PY_VERSION_HEX < 0x02020000)
1477 : data->newraw = 0;
1478 : #else
1479 0 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1480 : #endif
1481 0 : if (data->newraw) {
1482 0 : Py_INCREF(data->newraw);
1483 0 : data->newargs = PyTuple_New(1);
1484 0 : PyTuple_SetItem(data->newargs, 0, obj);
1485 : } else {
1486 0 : data->newargs = obj;
1487 : }
1488 0 : Py_INCREF(data->newargs);
1489 : }
1490 : /* the destroy method, aka as the C++ delete method */
1491 1 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1492 1 : if (PyErr_Occurred()) {
1493 0 : PyErr_Clear();
1494 0 : data->destroy = 0;
1495 : }
1496 1 : if (data->destroy) {
1497 : int flags;
1498 1 : Py_INCREF(data->destroy);
1499 1 : flags = PyCFunction_GET_FLAGS(data->destroy);
1500 : #ifdef METH_O
1501 1 : data->delargs = !(flags & (METH_O));
1502 : #else
1503 : data->delargs = 0;
1504 : #endif
1505 : } else {
1506 0 : data->delargs = 0;
1507 : }
1508 1 : data->implicitconv = 0;
1509 1 : data->pytype = 0;
1510 1 : return data;
1511 : }
1512 : }
1513 :
1514 : SWIGRUNTIME void
1515 1 : SwigPyClientData_Del(SwigPyClientData *data) {
1516 1 : Py_XDECREF(data->newraw);
1517 1 : Py_XDECREF(data->newargs);
1518 1 : Py_XDECREF(data->destroy);
1519 1 : }
1520 :
1521 : /* =============== SwigPyObject =====================*/
1522 :
1523 : typedef struct {
1524 : PyObject_HEAD
1525 : void *ptr;
1526 : swig_type_info *ty;
1527 : int own;
1528 : PyObject *next;
1529 : #ifdef SWIGPYTHON_BUILTIN
1530 : PyObject *dict;
1531 : #endif
1532 : } SwigPyObject;
1533 :
1534 :
1535 : #ifdef SWIGPYTHON_BUILTIN
1536 :
1537 : SWIGRUNTIME PyObject *
1538 : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1539 : {
1540 : SwigPyObject *sobj = (SwigPyObject *)v;
1541 :
1542 : if (!sobj->dict)
1543 : sobj->dict = PyDict_New();
1544 :
1545 : Py_INCREF(sobj->dict);
1546 : return sobj->dict;
1547 : }
1548 :
1549 : #endif
1550 :
1551 : SWIGRUNTIME PyObject *
1552 0 : SwigPyObject_long(SwigPyObject *v)
1553 : {
1554 0 : return PyLong_FromVoidPtr(v->ptr);
1555 : }
1556 :
1557 : SWIGRUNTIME PyObject *
1558 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1559 : {
1560 : PyObject *res = NULL;
1561 : PyObject *args = PyTuple_New(1);
1562 : if (args) {
1563 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1564 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1565 : if (ofmt) {
1566 : #if PY_VERSION_HEX >= 0x03000000
1567 : res = PyUnicode_Format(ofmt,args);
1568 : #else
1569 : res = PyString_Format(ofmt,args);
1570 : #endif
1571 : Py_DECREF(ofmt);
1572 : }
1573 : Py_DECREF(args);
1574 : }
1575 : }
1576 : return res;
1577 : }
1578 :
1579 : SWIGRUNTIME PyObject *
1580 : SwigPyObject_oct(SwigPyObject *v)
1581 : {
1582 : return SwigPyObject_format("%o",v);
1583 : }
1584 :
1585 : SWIGRUNTIME PyObject *
1586 : SwigPyObject_hex(SwigPyObject *v)
1587 : {
1588 : return SwigPyObject_format("%x",v);
1589 : }
1590 :
1591 : SWIGRUNTIME PyObject *
1592 : #ifdef METH_NOARGS
1593 1 : SwigPyObject_repr(SwigPyObject *v)
1594 : #else
1595 : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1596 : #endif
1597 : {
1598 1 : const char *name = SWIG_TypePrettyName(v->ty);
1599 1 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1600 1 : if (v->next) {
1601 : # ifdef METH_NOARGS
1602 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1603 : # else
1604 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1605 : # endif
1606 : # if PY_VERSION_HEX >= 0x03000000
1607 0 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1608 0 : Py_DecRef(repr);
1609 0 : Py_DecRef(nrep);
1610 : repr = joined;
1611 : # else
1612 : PyString_ConcatAndDel(&repr,nrep);
1613 : # endif
1614 : }
1615 1 : return repr;
1616 : }
1617 :
1618 : SWIGRUNTIME int
1619 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1620 : {
1621 : void *i = v->ptr;
1622 : void *j = w->ptr;
1623 0 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1624 : }
1625 :
1626 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1627 : SWIGRUNTIME PyObject*
1628 0 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1629 : {
1630 : PyObject* res;
1631 0 : if( op != Py_EQ && op != Py_NE ) {
1632 0 : Py_INCREF(Py_NotImplemented);
1633 0 : return Py_NotImplemented;
1634 : }
1635 0 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1636 0 : return res;
1637 : }
1638 :
1639 :
1640 : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1641 :
1642 : #ifdef SWIGPYTHON_BUILTIN
1643 : static swig_type_info *SwigPyObject_stype = 0;
1644 : SWIGRUNTIME PyTypeObject*
1645 : SwigPyObject_type(void) {
1646 : SwigPyClientData *cd;
1647 : assert(SwigPyObject_stype);
1648 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1649 : assert(cd);
1650 : assert(cd->pytype);
1651 : return cd->pytype;
1652 : }
1653 : #else
1654 : SWIGRUNTIME PyTypeObject*
1655 : SwigPyObject_type(void) {
1656 1 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1657 1 : return type;
1658 : }
1659 : #endif
1660 :
1661 : SWIGRUNTIMEINLINE int
1662 1 : SwigPyObject_Check(PyObject *op) {
1663 : #ifdef SWIGPYTHON_BUILTIN
1664 : PyTypeObject *target_tp = SwigPyObject_type();
1665 : if (PyType_IsSubtype(op->ob_type, target_tp))
1666 : return 1;
1667 : return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1668 : #else
1669 1 : return (Py_TYPE(op) == SwigPyObject_type())
1670 1 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1671 : #endif
1672 : }
1673 :
1674 : SWIGRUNTIME PyObject *
1675 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1676 :
1677 : SWIGRUNTIME void
1678 1 : SwigPyObject_dealloc(PyObject *v)
1679 : {
1680 : SwigPyObject *sobj = (SwigPyObject *) v;
1681 1 : PyObject *next = sobj->next;
1682 1 : if (sobj->own == SWIG_POINTER_OWN) {
1683 1 : swig_type_info *ty = sobj->ty;
1684 1 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1685 1 : PyObject *destroy = data ? data->destroy : 0;
1686 1 : if (destroy) {
1687 : /* destroy is always a VARARGS method */
1688 : PyObject *res;
1689 :
1690 : /* PyObject_CallFunction() has the potential to silently drop
1691 : the active active exception. In cases of unnamed temporary
1692 : variable or where we just finished iterating over a generator
1693 : StopIteration will be active right now, and this needs to
1694 : remain true upon return from SwigPyObject_dealloc. So save
1695 : and restore. */
1696 :
1697 1 : PyObject *val = NULL, *type = NULL, *tb = NULL;
1698 1 : PyErr_Fetch(&val, &type, &tb);
1699 :
1700 1 : if (data->delargs) {
1701 : /* we need to create a temporary object to carry the destroy operation */
1702 1 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1703 1 : res = SWIG_Python_CallFunctor(destroy, tmp);
1704 1 : Py_DECREF(tmp);
1705 : } else {
1706 0 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1707 0 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1708 0 : res = ((*meth)(mself, v));
1709 : }
1710 1 : if (!res)
1711 0 : PyErr_WriteUnraisable(destroy);
1712 :
1713 1 : PyErr_Restore(val, type, tb);
1714 :
1715 1 : Py_XDECREF(res);
1716 : }
1717 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1718 : else {
1719 : const char *name = SWIG_TypePrettyName(ty);
1720 0 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1721 : }
1722 : #endif
1723 : }
1724 1 : Py_XDECREF(next);
1725 1 : PyObject_DEL(v);
1726 1 : }
1727 :
1728 : SWIGRUNTIME PyObject*
1729 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1730 : {
1731 : SwigPyObject *sobj = (SwigPyObject *) v;
1732 : #ifndef METH_O
1733 : PyObject *tmp = 0;
1734 : if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1735 : next = tmp;
1736 : #endif
1737 0 : if (!SwigPyObject_Check(next)) {
1738 0 : PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1739 0 : return NULL;
1740 : }
1741 0 : sobj->next = next;
1742 0 : Py_INCREF(next);
1743 0 : return SWIG_Py_Void();
1744 : }
1745 :
1746 : SWIGRUNTIME PyObject*
1747 : #ifdef METH_NOARGS
1748 0 : SwigPyObject_next(PyObject* v)
1749 : #else
1750 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1751 : #endif
1752 : {
1753 : SwigPyObject *sobj = (SwigPyObject *) v;
1754 0 : if (sobj->next) {
1755 0 : Py_INCREF(sobj->next);
1756 0 : return sobj->next;
1757 : } else {
1758 0 : return SWIG_Py_Void();
1759 : }
1760 : }
1761 :
1762 : SWIGINTERN PyObject*
1763 : #ifdef METH_NOARGS
1764 0 : SwigPyObject_disown(PyObject *v)
1765 : #else
1766 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1767 : #endif
1768 : {
1769 : SwigPyObject *sobj = (SwigPyObject *)v;
1770 0 : sobj->own = 0;
1771 0 : return SWIG_Py_Void();
1772 : }
1773 :
1774 : SWIGINTERN PyObject*
1775 : #ifdef METH_NOARGS
1776 0 : SwigPyObject_acquire(PyObject *v)
1777 : #else
1778 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1779 : #endif
1780 : {
1781 : SwigPyObject *sobj = (SwigPyObject *)v;
1782 0 : sobj->own = SWIG_POINTER_OWN;
1783 0 : return SWIG_Py_Void();
1784 : }
1785 :
1786 : SWIGINTERN PyObject*
1787 1 : SwigPyObject_own(PyObject *v, PyObject *args)
1788 : {
1789 1 : PyObject *val = 0;
1790 : #if (PY_VERSION_HEX < 0x02020000)
1791 : if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1792 : #elif (PY_VERSION_HEX < 0x02050000)
1793 : if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1794 : #else
1795 1 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1796 : #endif
1797 : {
1798 : return NULL;
1799 : }
1800 : else
1801 : {
1802 : SwigPyObject *sobj = (SwigPyObject *)v;
1803 1 : PyObject *obj = PyBool_FromLong(sobj->own);
1804 1 : if (val) {
1805 : #ifdef METH_NOARGS
1806 0 : if (PyObject_IsTrue(val)) {
1807 : SwigPyObject_acquire(v);
1808 : } else {
1809 : SwigPyObject_disown(v);
1810 : }
1811 : #else
1812 : if (PyObject_IsTrue(val)) {
1813 : SwigPyObject_acquire(v,args);
1814 : } else {
1815 : SwigPyObject_disown(v,args);
1816 : }
1817 : #endif
1818 : }
1819 : return obj;
1820 : }
1821 : }
1822 :
1823 : #ifdef METH_O
1824 : static PyMethodDef
1825 : swigobject_methods[] = {
1826 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1827 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1828 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1829 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1830 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1831 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1832 : {0, 0, 0, 0}
1833 : };
1834 : #else
1835 : static PyMethodDef
1836 : swigobject_methods[] = {
1837 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1838 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1839 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1840 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1841 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1842 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1843 : {0, 0, 0, 0}
1844 : };
1845 : #endif
1846 :
1847 : #if PY_VERSION_HEX < 0x02020000
1848 : SWIGINTERN PyObject *
1849 : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1850 : {
1851 : return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1852 : }
1853 : #endif
1854 :
1855 : SWIGRUNTIME PyTypeObject*
1856 1 : SwigPyObject_TypeOnce(void) {
1857 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1858 :
1859 : static PyNumberMethods SwigPyObject_as_number = {
1860 : (binaryfunc)0, /*nb_add*/
1861 : (binaryfunc)0, /*nb_subtract*/
1862 : (binaryfunc)0, /*nb_multiply*/
1863 : /* nb_divide removed in Python 3 */
1864 : #if PY_VERSION_HEX < 0x03000000
1865 : (binaryfunc)0, /*nb_divide*/
1866 : #endif
1867 : (binaryfunc)0, /*nb_remainder*/
1868 : (binaryfunc)0, /*nb_divmod*/
1869 : (ternaryfunc)0,/*nb_power*/
1870 : (unaryfunc)0, /*nb_negative*/
1871 : (unaryfunc)0, /*nb_positive*/
1872 : (unaryfunc)0, /*nb_absolute*/
1873 : (inquiry)0, /*nb_nonzero*/
1874 : 0, /*nb_invert*/
1875 : 0, /*nb_lshift*/
1876 : 0, /*nb_rshift*/
1877 : 0, /*nb_and*/
1878 : 0, /*nb_xor*/
1879 : 0, /*nb_or*/
1880 : #if PY_VERSION_HEX < 0x03000000
1881 : 0, /*nb_coerce*/
1882 : #endif
1883 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1884 : #if PY_VERSION_HEX < 0x03000000
1885 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1886 : #else
1887 : 0, /*nb_reserved*/
1888 : #endif
1889 : (unaryfunc)0, /*nb_float*/
1890 : #if PY_VERSION_HEX < 0x03000000
1891 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1892 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1893 : #endif
1894 : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1895 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1896 : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1897 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1898 : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1899 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1900 : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1901 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1902 : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1903 : 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1904 : #endif
1905 : };
1906 :
1907 : static PyTypeObject swigpyobject_type;
1908 : static int type_init = 0;
1909 1 : if (!type_init) {
1910 : const PyTypeObject tmp = {
1911 : #if PY_VERSION_HEX >= 0x03000000
1912 : PyVarObject_HEAD_INIT(NULL, 0)
1913 : #else
1914 : PyObject_HEAD_INIT(NULL)
1915 : 0, /* ob_size */
1916 : #endif
1917 : (char *)"SwigPyObject", /* tp_name */
1918 : sizeof(SwigPyObject), /* tp_basicsize */
1919 : 0, /* tp_itemsize */
1920 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1921 : 0, /* tp_print */
1922 : #if PY_VERSION_HEX < 0x02020000
1923 : (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1924 : #else
1925 : (getattrfunc)0, /* tp_getattr */
1926 : #endif
1927 : (setattrfunc)0, /* tp_setattr */
1928 : #if PY_VERSION_HEX >= 0x03000000
1929 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1930 : #else
1931 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1932 : #endif
1933 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1934 : &SwigPyObject_as_number, /* tp_as_number */
1935 : 0, /* tp_as_sequence */
1936 : 0, /* tp_as_mapping */
1937 : (hashfunc)0, /* tp_hash */
1938 : (ternaryfunc)0, /* tp_call */
1939 : 0, /* tp_str */
1940 : PyObject_GenericGetAttr, /* tp_getattro */
1941 : 0, /* tp_setattro */
1942 : 0, /* tp_as_buffer */
1943 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1944 : swigobject_doc, /* tp_doc */
1945 : 0, /* tp_traverse */
1946 : 0, /* tp_clear */
1947 : (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1948 : 0, /* tp_weaklistoffset */
1949 : #if PY_VERSION_HEX >= 0x02020000
1950 : 0, /* tp_iter */
1951 : 0, /* tp_iternext */
1952 : swigobject_methods, /* tp_methods */
1953 : 0, /* tp_members */
1954 : 0, /* tp_getset */
1955 : 0, /* tp_base */
1956 : 0, /* tp_dict */
1957 : 0, /* tp_descr_get */
1958 : 0, /* tp_descr_set */
1959 : 0, /* tp_dictoffset */
1960 : 0, /* tp_init */
1961 : 0, /* tp_alloc */
1962 : 0, /* tp_new */
1963 : 0, /* tp_free */
1964 : 0, /* tp_is_gc */
1965 : 0, /* tp_bases */
1966 : 0, /* tp_mro */
1967 : 0, /* tp_cache */
1968 : 0, /* tp_subclasses */
1969 : 0, /* tp_weaklist */
1970 : #endif
1971 : #if PY_VERSION_HEX >= 0x02030000
1972 : 0, /* tp_del */
1973 : #endif
1974 : #if PY_VERSION_HEX >= 0x02060000
1975 : 0, /* tp_version_tag */
1976 : #endif
1977 : #if PY_VERSION_HEX >= 0x03040000
1978 : 0, /* tp_finalize */
1979 : #endif
1980 : #ifdef COUNT_ALLOCS
1981 : 0, /* tp_allocs */
1982 : 0, /* tp_frees */
1983 : 0, /* tp_maxalloc */
1984 : #if PY_VERSION_HEX >= 0x02050000
1985 : 0, /* tp_prev */
1986 : #endif
1987 : 0 /* tp_next */
1988 : #endif
1989 : };
1990 1 : swigpyobject_type = tmp;
1991 1 : type_init = 1;
1992 : #if PY_VERSION_HEX < 0x02020000
1993 : swigpyobject_type.ob_type = &PyType_Type;
1994 : #else
1995 1 : if (PyType_Ready(&swigpyobject_type) < 0)
1996 : return NULL;
1997 : #endif
1998 : }
1999 : return &swigpyobject_type;
2000 : }
2001 :
2002 : SWIGRUNTIME PyObject *
2003 1 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
2004 : {
2005 1 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2006 1 : if (sobj) {
2007 1 : sobj->ptr = ptr;
2008 1 : sobj->ty = ty;
2009 1 : sobj->own = own;
2010 1 : sobj->next = 0;
2011 : }
2012 1 : return (PyObject *)sobj;
2013 : }
2014 :
2015 : /* -----------------------------------------------------------------------------
2016 : * Implements a simple Swig Packed type, and use it instead of string
2017 : * ----------------------------------------------------------------------------- */
2018 :
2019 : typedef struct {
2020 : PyObject_HEAD
2021 : void *pack;
2022 : swig_type_info *ty;
2023 : size_t size;
2024 : } SwigPyPacked;
2025 :
2026 : SWIGRUNTIME int
2027 0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2028 : {
2029 : char result[SWIG_BUFFER_SIZE];
2030 0 : fputs("<Swig Packed ", fp);
2031 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2032 0 : fputs("at ", fp);
2033 0 : fputs(result, fp);
2034 : }
2035 0 : fputs(v->ty->name,fp);
2036 0 : fputs(">", fp);
2037 0 : return 0;
2038 : }
2039 :
2040 : SWIGRUNTIME PyObject *
2041 0 : SwigPyPacked_repr(SwigPyPacked *v)
2042 : {
2043 : char result[SWIG_BUFFER_SIZE];
2044 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2045 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2046 : } else {
2047 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2048 : }
2049 : }
2050 :
2051 : SWIGRUNTIME PyObject *
2052 0 : SwigPyPacked_str(SwigPyPacked *v)
2053 : {
2054 : char result[SWIG_BUFFER_SIZE];
2055 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2056 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2057 : } else {
2058 0 : return SWIG_Python_str_FromChar(v->ty->name);
2059 : }
2060 : }
2061 :
2062 : SWIGRUNTIME int
2063 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2064 : {
2065 : size_t i = v->size;
2066 : size_t j = w->size;
2067 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2068 : return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2069 : }
2070 :
2071 : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2072 :
2073 : SWIGRUNTIME PyTypeObject*
2074 : SwigPyPacked_type(void) {
2075 0 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2076 0 : return type;
2077 : }
2078 :
2079 : SWIGRUNTIMEINLINE int
2080 0 : SwigPyPacked_Check(PyObject *op) {
2081 0 : return ((op)->ob_type == SwigPyPacked_TypeOnce())
2082 0 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2083 : }
2084 :
2085 : SWIGRUNTIME void
2086 0 : SwigPyPacked_dealloc(PyObject *v)
2087 : {
2088 0 : if (SwigPyPacked_Check(v)) {
2089 : SwigPyPacked *sobj = (SwigPyPacked *) v;
2090 0 : free(sobj->pack);
2091 : }
2092 0 : PyObject_DEL(v);
2093 0 : }
2094 :
2095 : SWIGRUNTIME PyTypeObject*
2096 0 : SwigPyPacked_TypeOnce(void) {
2097 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2098 : static PyTypeObject swigpypacked_type;
2099 : static int type_init = 0;
2100 0 : if (!type_init) {
2101 : const PyTypeObject tmp = {
2102 : #if PY_VERSION_HEX>=0x03000000
2103 : PyVarObject_HEAD_INIT(NULL, 0)
2104 : #else
2105 : PyObject_HEAD_INIT(NULL)
2106 : 0, /* ob_size */
2107 : #endif
2108 : (char *)"SwigPyPacked", /* tp_name */
2109 : sizeof(SwigPyPacked), /* tp_basicsize */
2110 : 0, /* tp_itemsize */
2111 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2112 : (printfunc)SwigPyPacked_print, /* tp_print */
2113 : (getattrfunc)0, /* tp_getattr */
2114 : (setattrfunc)0, /* tp_setattr */
2115 : #if PY_VERSION_HEX>=0x03000000
2116 : 0, /* tp_reserved in 3.0.1 */
2117 : #else
2118 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2119 : #endif
2120 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
2121 : 0, /* tp_as_number */
2122 : 0, /* tp_as_sequence */
2123 : 0, /* tp_as_mapping */
2124 : (hashfunc)0, /* tp_hash */
2125 : (ternaryfunc)0, /* tp_call */
2126 : (reprfunc)SwigPyPacked_str, /* tp_str */
2127 : PyObject_GenericGetAttr, /* tp_getattro */
2128 : 0, /* tp_setattro */
2129 : 0, /* tp_as_buffer */
2130 : Py_TPFLAGS_DEFAULT, /* tp_flags */
2131 : swigpacked_doc, /* tp_doc */
2132 : 0, /* tp_traverse */
2133 : 0, /* tp_clear */
2134 : 0, /* tp_richcompare */
2135 : 0, /* tp_weaklistoffset */
2136 : #if PY_VERSION_HEX >= 0x02020000
2137 : 0, /* tp_iter */
2138 : 0, /* tp_iternext */
2139 : 0, /* tp_methods */
2140 : 0, /* tp_members */
2141 : 0, /* tp_getset */
2142 : 0, /* tp_base */
2143 : 0, /* tp_dict */
2144 : 0, /* tp_descr_get */
2145 : 0, /* tp_descr_set */
2146 : 0, /* tp_dictoffset */
2147 : 0, /* tp_init */
2148 : 0, /* tp_alloc */
2149 : 0, /* tp_new */
2150 : 0, /* tp_free */
2151 : 0, /* tp_is_gc */
2152 : 0, /* tp_bases */
2153 : 0, /* tp_mro */
2154 : 0, /* tp_cache */
2155 : 0, /* tp_subclasses */
2156 : 0, /* tp_weaklist */
2157 : #endif
2158 : #if PY_VERSION_HEX >= 0x02030000
2159 : 0, /* tp_del */
2160 : #endif
2161 : #if PY_VERSION_HEX >= 0x02060000
2162 : 0, /* tp_version_tag */
2163 : #endif
2164 : #if PY_VERSION_HEX >= 0x03040000
2165 : 0, /* tp_finalize */
2166 : #endif
2167 : #ifdef COUNT_ALLOCS
2168 : 0, /* tp_allocs */
2169 : 0, /* tp_frees */
2170 : 0, /* tp_maxalloc */
2171 : #if PY_VERSION_HEX >= 0x02050000
2172 : 0, /* tp_prev */
2173 : #endif
2174 : 0 /* tp_next */
2175 : #endif
2176 : };
2177 0 : swigpypacked_type = tmp;
2178 0 : type_init = 1;
2179 : #if PY_VERSION_HEX < 0x02020000
2180 : swigpypacked_type.ob_type = &PyType_Type;
2181 : #else
2182 0 : if (PyType_Ready(&swigpypacked_type) < 0)
2183 : return NULL;
2184 : #endif
2185 : }
2186 : return &swigpypacked_type;
2187 : }
2188 :
2189 : SWIGRUNTIME PyObject *
2190 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2191 : {
2192 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2193 0 : if (sobj) {
2194 0 : void *pack = malloc(size);
2195 0 : if (pack) {
2196 : memcpy(pack, ptr, size);
2197 0 : sobj->pack = pack;
2198 0 : sobj->ty = ty;
2199 0 : sobj->size = size;
2200 : } else {
2201 0 : PyObject_DEL((PyObject *) sobj);
2202 : sobj = 0;
2203 : }
2204 : }
2205 0 : return (PyObject *) sobj;
2206 : }
2207 :
2208 : SWIGRUNTIME swig_type_info *
2209 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2210 : {
2211 : if (SwigPyPacked_Check(obj)) {
2212 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
2213 : if (sobj->size != size) return 0;
2214 : memcpy(ptr, sobj->pack, size);
2215 : return sobj->ty;
2216 : } else {
2217 : return 0;
2218 : }
2219 : }
2220 :
2221 : /* -----------------------------------------------------------------------------
2222 : * pointers/data manipulation
2223 : * ----------------------------------------------------------------------------- */
2224 :
2225 : SWIGRUNTIMEINLINE PyObject *
2226 : _SWIG_This(void)
2227 : {
2228 : return SWIG_Python_str_FromChar("this");
2229 : }
2230 :
2231 : static PyObject *swig_this = NULL;
2232 :
2233 : SWIGRUNTIME PyObject *
2234 : SWIG_This(void)
2235 : {
2236 1 : if (swig_this == NULL)
2237 1 : swig_this = _SWIG_This();
2238 1 : return swig_this;
2239 : }
2240 :
2241 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2242 :
2243 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2244 : #if PY_VERSION_HEX>=0x03000000
2245 : #define SWIG_PYTHON_SLOW_GETSET_THIS
2246 : #endif
2247 :
2248 : SWIGRUNTIME SwigPyObject *
2249 1 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2250 : {
2251 : PyObject *obj;
2252 :
2253 1 : if (SwigPyObject_Check(pyobj))
2254 : return (SwigPyObject *) pyobj;
2255 :
2256 : #ifdef SWIGPYTHON_BUILTIN
2257 : (void)obj;
2258 : # ifdef PyWeakref_CheckProxy
2259 : if (PyWeakref_CheckProxy(pyobj)) {
2260 : pyobj = PyWeakref_GET_OBJECT(pyobj);
2261 : if (pyobj && SwigPyObject_Check(pyobj))
2262 : return (SwigPyObject*) pyobj;
2263 : }
2264 : # endif
2265 : return NULL;
2266 : #else
2267 :
2268 : obj = 0;
2269 :
2270 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2271 : if (PyInstance_Check(pyobj)) {
2272 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2273 : } else {
2274 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2275 : if (dictptr != NULL) {
2276 : PyObject *dict = *dictptr;
2277 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2278 : } else {
2279 : #ifdef PyWeakref_CheckProxy
2280 : if (PyWeakref_CheckProxy(pyobj)) {
2281 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2282 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2283 : }
2284 : #endif
2285 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2286 : if (obj) {
2287 : Py_DECREF(obj);
2288 : } else {
2289 : if (PyErr_Occurred()) PyErr_Clear();
2290 : return 0;
2291 : }
2292 : }
2293 : }
2294 : #else
2295 1 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2296 1 : if (obj) {
2297 1 : Py_DECREF(obj);
2298 : } else {
2299 0 : if (PyErr_Occurred()) PyErr_Clear();
2300 : return 0;
2301 : }
2302 : #endif
2303 1 : if (obj && !SwigPyObject_Check(obj)) {
2304 : /* a PyObject is called 'this', try to get the 'real this'
2305 : SwigPyObject from it */
2306 : return SWIG_Python_GetSwigThis(obj);
2307 : }
2308 : return (SwigPyObject *)obj;
2309 : #endif
2310 : }
2311 :
2312 : /* Acquire a pointer value */
2313 :
2314 : SWIGRUNTIME int
2315 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2316 : if (own == SWIG_POINTER_OWN) {
2317 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2318 : if (sobj) {
2319 : int oldown = sobj->own;
2320 : sobj->own = own;
2321 : return oldown;
2322 : }
2323 : }
2324 : return 0;
2325 : }
2326 :
2327 : /* Convert a pointer value */
2328 :
2329 : SWIGRUNTIME int
2330 1 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2331 : int res;
2332 : SwigPyObject *sobj;
2333 1 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2334 :
2335 1 : if (!obj)
2336 : return SWIG_ERROR;
2337 1 : if (obj == Py_None && !implicit_conv) {
2338 1 : if (ptr)
2339 1 : *ptr = 0;
2340 : return SWIG_OK;
2341 : }
2342 :
2343 : res = SWIG_ERROR;
2344 :
2345 1 : sobj = SWIG_Python_GetSwigThis(obj);
2346 1 : if (own)
2347 0 : *own = 0;
2348 1 : while (sobj) {
2349 1 : void *vptr = sobj->ptr;
2350 1 : if (ty) {
2351 1 : swig_type_info *to = sobj->ty;
2352 1 : if (to == ty) {
2353 : /* no type cast needed */
2354 1 : if (ptr) *ptr = vptr;
2355 : break;
2356 : } else {
2357 0 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2358 0 : if (!tc) {
2359 0 : sobj = (SwigPyObject *)sobj->next;
2360 : } else {
2361 0 : if (ptr) {
2362 0 : int newmemory = 0;
2363 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2364 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2365 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2366 0 : if (own)
2367 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2368 : }
2369 : }
2370 : break;
2371 : }
2372 : }
2373 : } else {
2374 0 : if (ptr) *ptr = vptr;
2375 : break;
2376 : }
2377 : }
2378 1 : if (sobj) {
2379 1 : if (own)
2380 0 : *own = *own | sobj->own;
2381 1 : if (flags & SWIG_POINTER_DISOWN) {
2382 1 : sobj->own = 0;
2383 : }
2384 : res = SWIG_OK;
2385 : } else {
2386 0 : if (implicit_conv) {
2387 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2388 0 : if (data && !data->implicitconv) {
2389 0 : PyObject *klass = data->klass;
2390 0 : if (klass) {
2391 : PyObject *impconv;
2392 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2393 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2394 0 : data->implicitconv = 0;
2395 0 : if (PyErr_Occurred()) {
2396 0 : PyErr_Clear();
2397 : impconv = 0;
2398 : }
2399 0 : if (impconv) {
2400 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2401 0 : if (iobj) {
2402 : void *vptr;
2403 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2404 0 : if (SWIG_IsOK(res)) {
2405 0 : if (ptr) {
2406 0 : *ptr = vptr;
2407 : /* transfer the ownership to 'ptr' */
2408 0 : iobj->own = 0;
2409 : res = SWIG_AddCast(res);
2410 0 : res = SWIG_AddNewMask(res);
2411 : } else {
2412 : res = SWIG_AddCast(res);
2413 : }
2414 : }
2415 : }
2416 0 : Py_DECREF(impconv);
2417 : }
2418 : }
2419 : }
2420 : }
2421 0 : if (!SWIG_IsOK(res) && obj == Py_None) {
2422 0 : if (ptr)
2423 0 : *ptr = 0;
2424 0 : if (PyErr_Occurred())
2425 0 : PyErr_Clear();
2426 : res = SWIG_OK;
2427 : }
2428 : }
2429 : return res;
2430 : }
2431 :
2432 : /* Convert a function ptr value */
2433 :
2434 : SWIGRUNTIME int
2435 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2436 : if (!PyCFunction_Check(obj)) {
2437 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2438 : } else {
2439 : void *vptr = 0;
2440 :
2441 : /* here we get the method pointer for callbacks */
2442 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2443 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2444 : if (desc)
2445 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2446 : if (!desc)
2447 : return SWIG_ERROR;
2448 : if (ty) {
2449 : swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2450 : if (tc) {
2451 : int newmemory = 0;
2452 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2453 : assert(!newmemory); /* newmemory handling not yet implemented */
2454 : } else {
2455 : return SWIG_ERROR;
2456 : }
2457 : } else {
2458 : *ptr = vptr;
2459 : }
2460 : return SWIG_OK;
2461 : }
2462 : }
2463 :
2464 : /* Convert a packed value value */
2465 :
2466 : SWIGRUNTIME int
2467 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2468 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2469 : if (!to) return SWIG_ERROR;
2470 : if (ty) {
2471 : if (to != ty) {
2472 : /* check type cast? */
2473 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2474 : if (!tc) return SWIG_ERROR;
2475 : }
2476 : }
2477 : return SWIG_OK;
2478 : }
2479 :
2480 : /* -----------------------------------------------------------------------------
2481 : * Create a new pointer object
2482 : * ----------------------------------------------------------------------------- */
2483 :
2484 : /*
2485 : Create a new instance object, without calling __init__, and set the
2486 : 'this' attribute.
2487 : */
2488 :
2489 : SWIGRUNTIME PyObject*
2490 1 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2491 : {
2492 : #if (PY_VERSION_HEX >= 0x02020000)
2493 : PyObject *inst = 0;
2494 1 : PyObject *newraw = data->newraw;
2495 1 : if (newraw) {
2496 0 : inst = PyObject_Call(newraw, data->newargs, NULL);
2497 0 : if (inst) {
2498 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2499 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2500 : if (dictptr != NULL) {
2501 : PyObject *dict = *dictptr;
2502 : if (dict == NULL) {
2503 : dict = PyDict_New();
2504 : *dictptr = dict;
2505 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2506 : }
2507 : }
2508 : #else
2509 : PyObject *key = SWIG_This();
2510 0 : PyObject_SetAttr(inst, key, swig_this);
2511 : #endif
2512 : }
2513 : } else {
2514 : #if PY_VERSION_HEX >= 0x03000000
2515 1 : inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2516 1 : if (inst) {
2517 1 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2518 1 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2519 : }
2520 : #else
2521 : PyObject *dict = PyDict_New();
2522 : if (dict) {
2523 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2524 : inst = PyInstance_NewRaw(data->newargs, dict);
2525 : Py_DECREF(dict);
2526 : }
2527 : #endif
2528 : }
2529 1 : return inst;
2530 : #else
2531 : #if (PY_VERSION_HEX >= 0x02010000)
2532 : PyObject *inst = 0;
2533 : PyObject *dict = PyDict_New();
2534 : if (dict) {
2535 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2536 : inst = PyInstance_NewRaw(data->newargs, dict);
2537 : Py_DECREF(dict);
2538 : }
2539 : return (PyObject *) inst;
2540 : #else
2541 : PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2542 : if (inst == NULL) {
2543 : return NULL;
2544 : }
2545 : inst->in_class = (PyClassObject *)data->newargs;
2546 : Py_INCREF(inst->in_class);
2547 : inst->in_dict = PyDict_New();
2548 : if (inst->in_dict == NULL) {
2549 : Py_DECREF(inst);
2550 : return NULL;
2551 : }
2552 : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2553 : inst->in_weakreflist = NULL;
2554 : #endif
2555 : #ifdef Py_TPFLAGS_GC
2556 : PyObject_GC_Init(inst);
2557 : #endif
2558 : PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2559 : return (PyObject *) inst;
2560 : #endif
2561 : #endif
2562 : }
2563 :
2564 : SWIGRUNTIME void
2565 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2566 : {
2567 : PyObject *dict;
2568 : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2569 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2570 : if (dictptr != NULL) {
2571 : dict = *dictptr;
2572 : if (dict == NULL) {
2573 : dict = PyDict_New();
2574 : *dictptr = dict;
2575 : }
2576 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2577 : return;
2578 : }
2579 : #endif
2580 : dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2581 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2582 : Py_DECREF(dict);
2583 : }
2584 :
2585 :
2586 : SWIGINTERN PyObject *
2587 : SWIG_Python_InitShadowInstance(PyObject *args) {
2588 : PyObject *obj[2];
2589 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2590 : return NULL;
2591 : } else {
2592 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2593 : if (sthis) {
2594 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2595 : } else {
2596 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2597 : }
2598 : return SWIG_Py_Void();
2599 : }
2600 : }
2601 :
2602 : /* Create a new pointer object */
2603 :
2604 : SWIGRUNTIME PyObject *
2605 1 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2606 : SwigPyClientData *clientdata;
2607 : PyObject * robj;
2608 : int own;
2609 :
2610 1 : if (!ptr)
2611 1 : return SWIG_Py_Void();
2612 :
2613 1 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2614 1 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2615 1 : if (clientdata && clientdata->pytype) {
2616 : SwigPyObject *newobj;
2617 0 : if (flags & SWIG_BUILTIN_TP_INIT) {
2618 : newobj = (SwigPyObject*) self;
2619 0 : if (newobj->ptr) {
2620 0 : PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2621 0 : while (newobj->next)
2622 : newobj = (SwigPyObject *) newobj->next;
2623 0 : newobj->next = next_self;
2624 : newobj = (SwigPyObject *)next_self;
2625 : #ifdef SWIGPYTHON_BUILTIN
2626 : newobj->dict = 0;
2627 : #endif
2628 : }
2629 : } else {
2630 0 : newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2631 : #ifdef SWIGPYTHON_BUILTIN
2632 : newobj->dict = 0;
2633 : #endif
2634 : }
2635 0 : if (newobj) {
2636 0 : newobj->ptr = ptr;
2637 0 : newobj->ty = type;
2638 0 : newobj->own = own;
2639 0 : newobj->next = 0;
2640 0 : return (PyObject*) newobj;
2641 : }
2642 0 : return SWIG_Py_Void();
2643 : }
2644 :
2645 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2646 :
2647 1 : robj = SwigPyObject_New(ptr, type, own);
2648 1 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2649 1 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2650 1 : Py_DECREF(robj);
2651 : robj = inst;
2652 : }
2653 : return robj;
2654 : }
2655 :
2656 : /* Create a new packed object */
2657 :
2658 : SWIGRUNTIMEINLINE PyObject *
2659 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2660 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2661 : }
2662 :
2663 : /* -----------------------------------------------------------------------------*
2664 : * Get type list
2665 : * -----------------------------------------------------------------------------*/
2666 :
2667 : #ifdef SWIG_LINK_RUNTIME
2668 : void *SWIG_ReturnGlobalTypeList(void *);
2669 : #endif
2670 :
2671 : SWIGRUNTIME swig_module_info *
2672 1 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2673 : static void *type_pointer = (void *)0;
2674 : /* first check if module already created */
2675 1 : if (!type_pointer) {
2676 : #ifdef SWIG_LINK_RUNTIME
2677 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2678 : #else
2679 : # ifdef SWIGPY_USE_CAPSULE
2680 1 : type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2681 : # else
2682 : type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2683 : (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2684 : # endif
2685 1 : if (PyErr_Occurred()) {
2686 1 : PyErr_Clear();
2687 1 : type_pointer = (void *)0;
2688 : }
2689 : #endif
2690 : }
2691 1 : return (swig_module_info *) type_pointer;
2692 : }
2693 :
2694 : #if PY_MAJOR_VERSION < 2
2695 : /* PyModule_AddObject function was introduced in Python 2.0. The following function
2696 : is copied out of Python/modsupport.c in python version 2.3.4 */
2697 : SWIGINTERN int
2698 : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2699 : {
2700 : PyObject *dict;
2701 : if (!PyModule_Check(m)) {
2702 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2703 : return SWIG_ERROR;
2704 : }
2705 : if (!o) {
2706 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2707 : return SWIG_ERROR;
2708 : }
2709 :
2710 : dict = PyModule_GetDict(m);
2711 : if (dict == NULL) {
2712 : /* Internal error -- modules must have a dict! */
2713 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2714 : PyModule_GetName(m));
2715 : return SWIG_ERROR;
2716 : }
2717 : if (PyDict_SetItemString(dict, name, o))
2718 : return SWIG_ERROR;
2719 : Py_DECREF(o);
2720 : return SWIG_OK;
2721 : }
2722 : #endif
2723 :
2724 : SWIGRUNTIME void
2725 : #ifdef SWIGPY_USE_CAPSULE
2726 1 : SWIG_Python_DestroyModule(PyObject *obj)
2727 : #else
2728 : SWIG_Python_DestroyModule(void *vptr)
2729 : #endif
2730 : {
2731 : #ifdef SWIGPY_USE_CAPSULE
2732 1 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2733 : #else
2734 : swig_module_info *swig_module = (swig_module_info *) vptr;
2735 : #endif
2736 1 : swig_type_info **types = swig_module->types;
2737 : size_t i;
2738 1 : for (i =0; i < swig_module->size; ++i) {
2739 1 : swig_type_info *ty = types[i];
2740 1 : if (ty->owndata) {
2741 1 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2742 1 : if (data) SwigPyClientData_Del(data);
2743 : }
2744 : }
2745 1 : Py_DECREF(SWIG_This());
2746 1 : swig_this = NULL;
2747 1 : }
2748 :
2749 : SWIGRUNTIME void
2750 1 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2751 : #if PY_VERSION_HEX >= 0x03000000
2752 : /* Add a dummy module object into sys.modules */
2753 1 : PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2754 : #else
2755 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2756 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2757 : #endif
2758 : #ifdef SWIGPY_USE_CAPSULE
2759 1 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2760 1 : if (pointer && module) {
2761 1 : PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2762 : } else {
2763 0 : Py_XDECREF(pointer);
2764 : }
2765 : #else
2766 : PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2767 : if (pointer && module) {
2768 : PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2769 : } else {
2770 : Py_XDECREF(pointer);
2771 : }
2772 : #endif
2773 1 : }
2774 :
2775 : /* The python cached type query */
2776 : SWIGRUNTIME PyObject *
2777 : SWIG_Python_TypeCache(void) {
2778 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2779 : return cache;
2780 : }
2781 :
2782 : SWIGRUNTIME swig_type_info *
2783 : SWIG_Python_TypeQuery(const char *type)
2784 : {
2785 : PyObject *cache = SWIG_Python_TypeCache();
2786 : PyObject *key = SWIG_Python_str_FromChar(type);
2787 : PyObject *obj = PyDict_GetItem(cache, key);
2788 : swig_type_info *descriptor;
2789 : if (obj) {
2790 : #ifdef SWIGPY_USE_CAPSULE
2791 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2792 : #else
2793 : descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2794 : #endif
2795 : } else {
2796 : swig_module_info *swig_module = SWIG_GetModule(0);
2797 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2798 : if (descriptor) {
2799 : #ifdef SWIGPY_USE_CAPSULE
2800 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2801 : #else
2802 : obj = PyCObject_FromVoidPtr(descriptor, NULL);
2803 : #endif
2804 : PyDict_SetItem(cache, key, obj);
2805 : Py_DECREF(obj);
2806 : }
2807 : }
2808 : Py_DECREF(key);
2809 : return descriptor;
2810 : }
2811 :
2812 : /*
2813 : For backward compatibility only
2814 : */
2815 : #define SWIG_POINTER_EXCEPTION 0
2816 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2817 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2818 :
2819 : SWIGRUNTIME int
2820 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2821 : {
2822 : if (PyErr_Occurred()) {
2823 : PyObject *type = 0;
2824 : PyObject *value = 0;
2825 : PyObject *traceback = 0;
2826 : PyErr_Fetch(&type, &value, &traceback);
2827 : if (value) {
2828 : char *tmp;
2829 : PyObject *old_str = PyObject_Str(value);
2830 : Py_XINCREF(type);
2831 : PyErr_Clear();
2832 : if (infront) {
2833 : PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2834 : } else {
2835 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2836 : }
2837 : SWIG_Python_str_DelForPy3(tmp);
2838 : Py_DECREF(old_str);
2839 : }
2840 : return 1;
2841 : } else {
2842 : return 0;
2843 : }
2844 : }
2845 :
2846 : SWIGRUNTIME int
2847 : SWIG_Python_ArgFail(int argnum)
2848 : {
2849 : if (PyErr_Occurred()) {
2850 : /* add information about failing argument */
2851 : char mesg[256];
2852 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2853 : return SWIG_Python_AddErrMesg(mesg, 1);
2854 : } else {
2855 : return 0;
2856 : }
2857 : }
2858 :
2859 : SWIGRUNTIMEINLINE const char *
2860 : SwigPyObject_GetDesc(PyObject *self)
2861 : {
2862 : SwigPyObject *v = (SwigPyObject *)self;
2863 : swig_type_info *ty = v ? v->ty : 0;
2864 : return ty ? ty->str : "";
2865 : }
2866 :
2867 : SWIGRUNTIME void
2868 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2869 : {
2870 : if (type) {
2871 : #if defined(SWIG_COBJECT_TYPES)
2872 : if (obj && SwigPyObject_Check(obj)) {
2873 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2874 : if (otype) {
2875 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2876 : type, otype);
2877 : return;
2878 : }
2879 : } else
2880 : #endif
2881 : {
2882 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2883 : if (otype) {
2884 : PyObject *str = PyObject_Str(obj);
2885 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2886 : if (cstr) {
2887 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2888 : type, otype, cstr);
2889 : SWIG_Python_str_DelForPy3(cstr);
2890 : } else {
2891 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2892 : type, otype);
2893 : }
2894 : Py_XDECREF(str);
2895 : return;
2896 : }
2897 : }
2898 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2899 : } else {
2900 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2901 : }
2902 : }
2903 :
2904 :
2905 : /* Convert a pointer value, signal an exception on a type mismatch */
2906 : SWIGRUNTIME void *
2907 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2908 : void *result;
2909 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2910 : PyErr_Clear();
2911 : #if SWIG_POINTER_EXCEPTION
2912 : if (flags) {
2913 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2914 : SWIG_Python_ArgFail(argnum);
2915 : }
2916 : #endif
2917 : }
2918 : return result;
2919 : }
2920 :
2921 : #ifdef SWIGPYTHON_BUILTIN
2922 : SWIGRUNTIME int
2923 : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2924 : PyTypeObject *tp = obj->ob_type;
2925 : PyObject *descr;
2926 : PyObject *encoded_name;
2927 : descrsetfunc f;
2928 : int res = -1;
2929 :
2930 : # ifdef Py_USING_UNICODE
2931 : if (PyString_Check(name)) {
2932 : name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2933 : if (!name)
2934 : return -1;
2935 : } else if (!PyUnicode_Check(name))
2936 : # else
2937 : if (!PyString_Check(name))
2938 : # endif
2939 : {
2940 : PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2941 : return -1;
2942 : } else {
2943 : Py_INCREF(name);
2944 : }
2945 :
2946 : if (!tp->tp_dict) {
2947 : if (PyType_Ready(tp) < 0)
2948 : goto done;
2949 : }
2950 :
2951 : descr = _PyType_Lookup(tp, name);
2952 : f = NULL;
2953 : if (descr != NULL)
2954 : f = descr->ob_type->tp_descr_set;
2955 : if (!f) {
2956 : if (PyString_Check(name)) {
2957 : encoded_name = name;
2958 : Py_INCREF(name);
2959 : } else {
2960 : encoded_name = PyUnicode_AsUTF8String(name);
2961 : }
2962 : PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2963 : Py_DECREF(encoded_name);
2964 : } else {
2965 : res = f(descr, obj, value);
2966 : }
2967 :
2968 : done:
2969 : Py_DECREF(name);
2970 : return res;
2971 : }
2972 : #endif
2973 :
2974 :
2975 : #ifdef __cplusplus
2976 : }
2977 : #endif
2978 :
2979 :
2980 :
2981 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2982 :
2983 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2984 :
2985 :
2986 :
2987 : #define SWIG_exception(code, msg) do { SWIG_Error(code, msg); SWIG_fail;; } while(0)
2988 :
2989 :
2990 : /* -------- TYPES TABLE (BEGIN) -------- */
2991 :
2992 : #define SWIGTYPE_p_CompositingOperation swig_types[0]
2993 : #define SWIGTYPE_p_DBFFieldType swig_types[1]
2994 : #define SWIGTYPE_p_DBFInfo swig_types[2]
2995 : #define SWIGTYPE_p__CompositingFilter swig_types[3]
2996 : #define SWIGTYPE_p__LayerCompositer swig_types[4]
2997 : #define SWIGTYPE_p_cgiRequestObj swig_types[5]
2998 : #define SWIGTYPE_p_char swig_types[6]
2999 : #define SWIGTYPE_p_classObj swig_types[7]
3000 : #define SWIGTYPE_p_clusterObj swig_types[8]
3001 : #define SWIGTYPE_p_colorObj swig_types[9]
3002 : #define SWIGTYPE_p_debugLevel swig_types[10]
3003 : #define SWIGTYPE_p_double swig_types[11]
3004 : #define SWIGTYPE_p_errorObj swig_types[12]
3005 : #define SWIGTYPE_p_expressionObj swig_types[13]
3006 : #define SWIGTYPE_p_fontSetObj swig_types[14]
3007 : #define SWIGTYPE_p_hashTableObj swig_types[15]
3008 : #define SWIGTYPE_p_imageObj swig_types[16]
3009 : #define SWIGTYPE_p_int swig_types[17]
3010 : #define SWIGTYPE_p_int32_t swig_types[18]
3011 : #define SWIGTYPE_p_intarray swig_types[19]
3012 : #define SWIGTYPE_p_labelCacheMemberObj swig_types[20]
3013 : #define SWIGTYPE_p_labelCacheObj swig_types[21]
3014 : #define SWIGTYPE_p_labelCacheSlotObj swig_types[22]
3015 : #define SWIGTYPE_p_labelLeaderObj swig_types[23]
3016 : #define SWIGTYPE_p_labelObj swig_types[24]
3017 : #define SWIGTYPE_p_layerObj swig_types[25]
3018 : #define SWIGTYPE_p_legendObj swig_types[26]
3019 : #define SWIGTYPE_p_lineObj swig_types[27]
3020 : #define SWIGTYPE_p_mapObj swig_types[28]
3021 : #define SWIGTYPE_p_markerCacheMemberObj swig_types[29]
3022 : #define SWIGTYPE_p_outputFormatObj swig_types[30]
3023 : #define SWIGTYPE_p_p_char swig_types[31]
3024 : #define SWIGTYPE_p_p_double swig_types[32]
3025 : #define SWIGTYPE_p_p_labelCacheMemberObj swig_types[33]
3026 : #define SWIGTYPE_p_p_textSymbolObj swig_types[34]
3027 : #define SWIGTYPE_p_pointObj swig_types[35]
3028 : #define SWIGTYPE_p_projectionContext swig_types[36]
3029 : #define SWIGTYPE_p_projectionObj swig_types[37]
3030 : #define SWIGTYPE_p_queryMapObj swig_types[38]
3031 : #define SWIGTYPE_p_rectObj swig_types[39]
3032 : #define SWIGTYPE_p_referenceMapObj swig_types[40]
3033 : #define SWIGTYPE_p_resultCacheObj swig_types[41]
3034 : #define SWIGTYPE_p_resultObj swig_types[42]
3035 : #define SWIGTYPE_p_scaleTokenEntryObj swig_types[43]
3036 : #define SWIGTYPE_p_scaleTokenObj swig_types[44]
3037 : #define SWIGTYPE_p_scalebarObj swig_types[45]
3038 : #define SWIGTYPE_p_shapeObj swig_types[46]
3039 : #define SWIGTYPE_p_shapefileObj swig_types[47]
3040 : #define SWIGTYPE_p_styleObj swig_types[48]
3041 : #define SWIGTYPE_p_symbolObj swig_types[49]
3042 : #define SWIGTYPE_p_symbolSetObj swig_types[50]
3043 : #define SWIGTYPE_p_uint32_t swig_types[51]
3044 : #define SWIGTYPE_p_void swig_types[52]
3045 : #define SWIGTYPE_p_webObj swig_types[53]
3046 : static swig_type_info *swig_types[55];
3047 : static swig_module_info swig_module = {swig_types, 54, 0, 0, 0, 0};
3048 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3049 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3050 :
3051 : /* -------- TYPES TABLE (END) -------- */
3052 :
3053 : #if (PY_VERSION_HEX <= 0x02000000)
3054 : # if !defined(SWIG_PYTHON_CLASSIC)
3055 : # error "This python version requires swig to be run with the '-classic' option"
3056 : # endif
3057 : #endif
3058 :
3059 : /*-----------------------------------------------
3060 : @(target):= _mapscript.so
3061 : ------------------------------------------------*/
3062 : #if PY_VERSION_HEX >= 0x03000000
3063 : # define SWIG_init PyInit__mapscript
3064 :
3065 : #else
3066 : # define SWIG_init init_mapscript
3067 :
3068 : #endif
3069 : #define SWIG_name "_mapscript"
3070 :
3071 : #define SWIGVERSION 0x030012
3072 : #define SWIG_VERSION SWIGVERSION
3073 :
3074 :
3075 : #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3076 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3077 :
3078 :
3079 : #include "../../mapserver.h"
3080 : #include "../../maptemplate.h"
3081 : #include "../../mapogcsld.h"
3082 : #include "../../mapows.h"
3083 : #include "../../cgiutil.h"
3084 : #include "../../mapcopy.h"
3085 : #include "../../maperror.h"
3086 : #include "../../mapprimitive.h"
3087 : #include "../../mapshape.h"
3088 :
3089 : #if defined(WIN32) && defined(SWIGCSHARP)
3090 : /* <windows.h> is needed for GetExceptionCode() for unhandled exception */
3091 : #include <windows.h>
3092 : #endif
3093 :
3094 :
3095 :
3096 : typedef int intarray;
3097 :
3098 :
3099 : SWIGINTERN int
3100 1 : SWIG_AsVal_double (PyObject *obj, double *val)
3101 : {
3102 : int res = SWIG_TypeError;
3103 1 : if (PyFloat_Check(obj)) {
3104 1 : if (val) *val = PyFloat_AsDouble(obj);
3105 : return SWIG_OK;
3106 : #if PY_VERSION_HEX < 0x03000000
3107 : } else if (PyInt_Check(obj)) {
3108 : if (val) *val = (double) PyInt_AsLong(obj);
3109 : return SWIG_OK;
3110 : #endif
3111 1 : } else if (PyLong_Check(obj)) {
3112 1 : double v = PyLong_AsDouble(obj);
3113 1 : if (!PyErr_Occurred()) {
3114 1 : if (val) *val = v;
3115 : return SWIG_OK;
3116 : } else {
3117 0 : PyErr_Clear();
3118 : }
3119 : }
3120 : #ifdef SWIG_PYTHON_CAST_MODE
3121 : {
3122 : int dispatch = 0;
3123 : double d = PyFloat_AsDouble(obj);
3124 : if (!PyErr_Occurred()) {
3125 : if (val) *val = d;
3126 : return SWIG_AddCast(SWIG_OK);
3127 : } else {
3128 : PyErr_Clear();
3129 : }
3130 : if (!dispatch) {
3131 : long v = PyLong_AsLong(obj);
3132 : if (!PyErr_Occurred()) {
3133 : if (val) *val = v;
3134 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3135 : } else {
3136 : PyErr_Clear();
3137 : }
3138 : }
3139 : }
3140 : #endif
3141 : return res;
3142 : }
3143 :
3144 :
3145 : #include <float.h>
3146 :
3147 :
3148 : #include <math.h>
3149 :
3150 :
3151 : SWIGINTERNINLINE int
3152 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3153 : double x = *d;
3154 : if ((min <= x && x <= max)) {
3155 : double fx = floor(x);
3156 : double cx = ceil(x);
3157 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3158 : if ((errno == EDOM) || (errno == ERANGE)) {
3159 : errno = 0;
3160 : } else {
3161 : double summ, reps, diff;
3162 : if (rd < x) {
3163 : diff = x - rd;
3164 : } else if (rd > x) {
3165 : diff = rd - x;
3166 : } else {
3167 : return 1;
3168 : }
3169 : summ = rd + x;
3170 : reps = diff/summ;
3171 : if (reps < 8*DBL_EPSILON) {
3172 : *d = rd;
3173 : return 1;
3174 : }
3175 : }
3176 : }
3177 : return 0;
3178 : }
3179 :
3180 :
3181 : SWIGINTERN int
3182 0 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3183 : {
3184 : #if PY_VERSION_HEX < 0x03000000
3185 : if (PyInt_Check(obj)) {
3186 : long v = PyInt_AsLong(obj);
3187 : if (v >= 0) {
3188 : if (val) *val = v;
3189 : return SWIG_OK;
3190 : } else {
3191 : return SWIG_OverflowError;
3192 : }
3193 : } else
3194 : #endif
3195 0 : if (PyLong_Check(obj)) {
3196 0 : unsigned long v = PyLong_AsUnsignedLong(obj);
3197 0 : if (!PyErr_Occurred()) {
3198 0 : if (val) *val = v;
3199 : return SWIG_OK;
3200 : } else {
3201 0 : PyErr_Clear();
3202 0 : return SWIG_OverflowError;
3203 : }
3204 : }
3205 : #ifdef SWIG_PYTHON_CAST_MODE
3206 : {
3207 : int dispatch = 0;
3208 : unsigned long v = PyLong_AsUnsignedLong(obj);
3209 : if (!PyErr_Occurred()) {
3210 : if (val) *val = v;
3211 : return SWIG_AddCast(SWIG_OK);
3212 : } else {
3213 : PyErr_Clear();
3214 : }
3215 : if (!dispatch) {
3216 : double d;
3217 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3218 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3219 : if (val) *val = (unsigned long)(d);
3220 : return res;
3221 : }
3222 : }
3223 : }
3224 : #endif
3225 : return SWIG_TypeError;
3226 : }
3227 :
3228 :
3229 : #include <limits.h>
3230 : #if !defined(SWIG_NO_LLONG_MAX)
3231 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3232 : # define LLONG_MAX __LONG_LONG_MAX__
3233 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3234 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3235 : # endif
3236 : #endif
3237 :
3238 :
3239 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3240 : # define SWIG_LONG_LONG_AVAILABLE
3241 : #endif
3242 :
3243 :
3244 : #ifdef SWIG_LONG_LONG_AVAILABLE
3245 : SWIGINTERN int
3246 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3247 : {
3248 : int res = SWIG_TypeError;
3249 : if (PyLong_Check(obj)) {
3250 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3251 : if (!PyErr_Occurred()) {
3252 : if (val) *val = v;
3253 : return SWIG_OK;
3254 : } else {
3255 : PyErr_Clear();
3256 : res = SWIG_OverflowError;
3257 : }
3258 : } else {
3259 : unsigned long v;
3260 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3261 : if (SWIG_IsOK(res)) {
3262 : if (val) *val = v;
3263 : return res;
3264 : }
3265 : }
3266 : #ifdef SWIG_PYTHON_CAST_MODE
3267 : {
3268 : const double mant_max = 1LL << DBL_MANT_DIG;
3269 : double d;
3270 : res = SWIG_AsVal_double (obj,&d);
3271 : if (SWIG_IsOK(res) && !SWIG_CanCastAsInteger(&d, 0, mant_max))
3272 : return SWIG_OverflowError;
3273 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3274 : if (val) *val = (unsigned long long)(d);
3275 : return SWIG_AddCast(res);
3276 : }
3277 : res = SWIG_TypeError;
3278 : }
3279 : #endif
3280 : return res;
3281 : }
3282 : #endif
3283 :
3284 :
3285 : SWIGINTERNINLINE int
3286 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3287 : {
3288 : int res = SWIG_TypeError;
3289 : #ifdef SWIG_LONG_LONG_AVAILABLE
3290 : if (sizeof(size_t) <= sizeof(unsigned long)) {
3291 : #endif
3292 : unsigned long v;
3293 0 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3294 0 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3295 : #ifdef SWIG_LONG_LONG_AVAILABLE
3296 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3297 : unsigned long long v;
3298 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3299 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3300 : }
3301 : #endif
3302 : return res;
3303 : }
3304 :
3305 : SWIGINTERN intarray *new_intarray(size_t nelements){
3306 0 : return (int *)calloc(nelements, sizeof(int));
3307 : }
3308 : SWIGINTERN void delete_intarray(intarray *self){
3309 0 : free((char*)self);
3310 : }
3311 : SWIGINTERN int intarray___getitem__(intarray *self,size_t index){
3312 0 : return self[index];
3313 : }
3314 :
3315 : SWIGINTERNINLINE PyObject*
3316 : SWIG_From_int (int value)
3317 : {
3318 1 : return PyInt_FromLong((long) value);
3319 : }
3320 :
3321 :
3322 : SWIGINTERN int
3323 1 : SWIG_AsVal_long (PyObject *obj, long* val)
3324 : {
3325 : #if PY_VERSION_HEX < 0x03000000
3326 : if (PyInt_Check(obj)) {
3327 : if (val) *val = PyInt_AsLong(obj);
3328 : return SWIG_OK;
3329 : } else
3330 : #endif
3331 1 : if (PyLong_Check(obj)) {
3332 1 : long v = PyLong_AsLong(obj);
3333 1 : if (!PyErr_Occurred()) {
3334 1 : if (val) *val = v;
3335 : return SWIG_OK;
3336 : } else {
3337 0 : PyErr_Clear();
3338 0 : return SWIG_OverflowError;
3339 : }
3340 : }
3341 : #ifdef SWIG_PYTHON_CAST_MODE
3342 : {
3343 : int dispatch = 0;
3344 : long v = PyInt_AsLong(obj);
3345 : if (!PyErr_Occurred()) {
3346 : if (val) *val = v;
3347 : return SWIG_AddCast(SWIG_OK);
3348 : } else {
3349 : PyErr_Clear();
3350 : }
3351 : if (!dispatch) {
3352 : double d;
3353 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3354 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3355 : if (val) *val = (long)(d);
3356 : return res;
3357 : }
3358 : }
3359 : }
3360 : #endif
3361 : return SWIG_TypeError;
3362 : }
3363 :
3364 :
3365 : SWIGINTERN int
3366 : SWIG_AsVal_int (PyObject * obj, int *val)
3367 : {
3368 : long v;
3369 1 : int res = SWIG_AsVal_long (obj, &v);
3370 1 : if (SWIG_IsOK(res)) {
3371 1 : if ((v < INT_MIN || v > INT_MAX)) {
3372 : return SWIG_OverflowError;
3373 : } else {
3374 1 : if (val) *val = (int)(v);
3375 : }
3376 : }
3377 : return res;
3378 : }
3379 :
3380 : SWIGINTERN void intarray___setitem__(intarray *self,size_t index,int value){
3381 0 : self[index] = value;
3382 : }
3383 : SWIGINTERN int *intarray_cast(intarray *self){
3384 : return self;
3385 : }
3386 : SWIGINTERN intarray *intarray_frompointer(int *t){
3387 : return (intarray *)(t);
3388 : }
3389 :
3390 : #ifdef __cplusplus
3391 : extern "C" {
3392 : #endif
3393 :
3394 : typedef struct {
3395 : unsigned char *data;
3396 : int size;
3397 : int owns_data;
3398 : } gdBuffer;
3399 :
3400 : #ifdef __cplusplus
3401 : }
3402 : #endif
3403 :
3404 :
3405 : PyObject *MSExc_MapServerError;
3406 : PyObject *MSExc_MapServerChildError;
3407 :
3408 :
3409 :
3410 : static void _raise_ms_exception( void );
3411 :
3412 1 : static void _raise_ms_exception() {
3413 : int errcode;
3414 : errorObj *ms_error;
3415 : char *errmsg;
3416 1 : ms_error = msGetErrorObj();
3417 1 : errcode = ms_error->code;
3418 1 : errmsg = msGetErrorString("\n");
3419 :
3420 1 : switch (errcode) {
3421 1 : case MS_IOERR:
3422 1 : PyErr_SetString(PyExc_IOError, errmsg);
3423 1 : break;
3424 0 : case MS_MEMERR:
3425 0 : PyErr_SetString(PyExc_MemoryError, errmsg);
3426 0 : break;
3427 0 : case MS_TYPEERR:
3428 0 : PyErr_SetString(PyExc_TypeError, errmsg);
3429 0 : break;
3430 0 : case MS_EOFERR:
3431 0 : PyErr_SetString(PyExc_EOFError, errmsg);
3432 0 : break;
3433 1 : case MS_CHILDERR:
3434 1 : PyErr_SetString(MSExc_MapServerChildError, errmsg);
3435 1 : break;
3436 1 : default:
3437 1 : PyErr_SetString(MSExc_MapServerError, errmsg);
3438 1 : break;
3439 : }
3440 :
3441 1 : free(errmsg);
3442 1 : }
3443 :
3444 :
3445 :
3446 : SWIGINTERN swig_type_info*
3447 1 : SWIG_pchar_descriptor(void)
3448 : {
3449 : static int init = 0;
3450 : static swig_type_info* info = 0;
3451 1 : if (!init) {
3452 1 : info = SWIG_TypeQuery("_p_char");
3453 1 : init = 1;
3454 : }
3455 1 : return info;
3456 : }
3457 :
3458 :
3459 : SWIGINTERN int
3460 1 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3461 : {
3462 : #if PY_VERSION_HEX>=0x03000000
3463 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3464 : if (PyBytes_Check(obj))
3465 : #else
3466 1 : if (PyUnicode_Check(obj))
3467 : #endif
3468 : #else
3469 : if (PyString_Check(obj))
3470 : #endif
3471 : {
3472 : char *cstr; Py_ssize_t len;
3473 : #if PY_VERSION_HEX>=0x03000000
3474 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3475 1 : if (!alloc && cptr) {
3476 : /* We can't allow converting without allocation, since the internal
3477 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3478 : a UTF-8 representation.
3479 : TODO(bhy) More detailed explanation */
3480 : return SWIG_RuntimeError;
3481 : }
3482 1 : obj = PyUnicode_AsUTF8String(obj);
3483 1 : if(alloc) *alloc = SWIG_NEWOBJ;
3484 : #endif
3485 1 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3486 : #else
3487 : PyString_AsStringAndSize(obj, &cstr, &len);
3488 : #endif
3489 1 : if (cptr) {
3490 1 : if (alloc) {
3491 : /*
3492 : In python the user should not be able to modify the inner
3493 : string representation. To warranty that, if you define
3494 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3495 : buffer is always returned.
3496 :
3497 : The default behavior is just to return the pointer value,
3498 : so, be careful.
3499 : */
3500 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3501 : if (*alloc != SWIG_OLDOBJ)
3502 : #else
3503 1 : if (*alloc == SWIG_NEWOBJ)
3504 : #endif
3505 : {
3506 1 : *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3507 1 : *alloc = SWIG_NEWOBJ;
3508 : } else {
3509 0 : *cptr = cstr;
3510 0 : *alloc = SWIG_OLDOBJ;
3511 : }
3512 : } else {
3513 : #if PY_VERSION_HEX>=0x03000000
3514 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3515 : *cptr = PyBytes_AsString(obj);
3516 : #else
3517 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3518 : #endif
3519 : #else
3520 : *cptr = SWIG_Python_str_AsChar(obj);
3521 : #endif
3522 : }
3523 : }
3524 1 : if (psize) *psize = len + 1;
3525 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3526 1 : Py_XDECREF(obj);
3527 : #endif
3528 : return SWIG_OK;
3529 : } else {
3530 : #if defined(SWIG_PYTHON_2_UNICODE)
3531 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3532 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3533 : #endif
3534 : #if PY_VERSION_HEX<0x03000000
3535 : if (PyUnicode_Check(obj)) {
3536 : char *cstr; Py_ssize_t len;
3537 : if (!alloc && cptr) {
3538 : return SWIG_RuntimeError;
3539 : }
3540 : obj = PyUnicode_AsUTF8String(obj);
3541 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3542 : if (cptr) {
3543 : if (alloc) *alloc = SWIG_NEWOBJ;
3544 : *cptr = (char *)memcpy(malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3545 : }
3546 : if (psize) *psize = len + 1;
3547 :
3548 : Py_XDECREF(obj);
3549 : return SWIG_OK;
3550 : } else {
3551 : Py_XDECREF(obj);
3552 : }
3553 : }
3554 : #endif
3555 : #endif
3556 :
3557 1 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3558 1 : if (pchar_descriptor) {
3559 1 : void* vptr = 0;
3560 1 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3561 1 : if (cptr) *cptr = (char *) vptr;
3562 1 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3563 1 : if (alloc) *alloc = SWIG_OLDOBJ;
3564 1 : return SWIG_OK;
3565 : }
3566 : }
3567 : }
3568 : return SWIG_TypeError;
3569 : }
3570 :
3571 :
3572 :
3573 :
3574 :
3575 : SWIGINTERNINLINE PyObject *
3576 1 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3577 : {
3578 1 : if (carray) {
3579 1 : if (size > INT_MAX) {
3580 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3581 : return pchar_descriptor ?
3582 0 : SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3583 : } else {
3584 : #if PY_VERSION_HEX >= 0x03000000
3585 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3586 : return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3587 : #else
3588 : #if PY_VERSION_HEX >= 0x03010000
3589 1 : return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3590 : #else
3591 : return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3592 : #endif
3593 : #endif
3594 : #else
3595 : return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3596 : #endif
3597 : }
3598 : } else {
3599 1 : return SWIG_Py_Void();
3600 : }
3601 : }
3602 :
3603 :
3604 : SWIGINTERNINLINE PyObject *
3605 1 : SWIG_FromCharPtr(const char *cptr)
3606 : {
3607 1 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3608 : }
3609 :
3610 :
3611 : #define SWIG_From_double PyFloat_FromDouble
3612 :
3613 : SWIGINTERN int clusterObj_updateFromString(clusterObj *self,char *snippet){
3614 1 : return msUpdateClusterFromString(self, snippet);
3615 : }
3616 : SWIGINTERN char *clusterObj_convertToString(clusterObj *self){
3617 1 : return msWriteClusterToString(self);
3618 : }
3619 1 : SWIGINTERN int clusterObj_setGroup(clusterObj *self,char *group){
3620 1 : if (!group || strlen(group) == 0) {
3621 0 : msFreeExpression(&self->group);
3622 0 : return MS_SUCCESS;
3623 : }
3624 1 : else return msLoadExpressionString(&self->group, group);
3625 : }
3626 : SWIGINTERN char *clusterObj_getGroupString(clusterObj *self){
3627 1 : return msGetExpressionString(&(self->group));
3628 : }
3629 1 : SWIGINTERN int clusterObj_setFilter(clusterObj *self,char *filter){
3630 1 : if (!filter || strlen(filter) == 0) {
3631 0 : msFreeExpression(&self->filter);
3632 0 : return MS_SUCCESS;
3633 : }
3634 1 : else return msLoadExpressionString(&self->filter, filter);
3635 : }
3636 : SWIGINTERN char *clusterObj_getFilterString(clusterObj *self){
3637 1 : return msGetExpressionString(&(self->filter));
3638 : }
3639 1 : SWIGINTERN outputFormatObj *new_outputFormatObj(char const *driver,char *name){
3640 : outputFormatObj *format;
3641 :
3642 1 : format = msCreateDefaultOutputFormat(NULL, driver, name);
3643 :
3644 : /* in the case of unsupported formats, msCreateDefaultOutputFormat
3645 : should return NULL */
3646 1 : if (!format)
3647 : {
3648 1 : msSetError(12, "Unsupported format driver: %s",
3649 : "outputFormatObj()", driver);
3650 1 : return NULL;
3651 : }
3652 :
3653 1 : msInitializeRendererVTable(format);
3654 :
3655 1 : MS_REFCNT_INIT(format);
3656 1 : format->inmapfile = 1;
3657 :
3658 1 : return format;
3659 : }
3660 : SWIGINTERN void delete_outputFormatObj(outputFormatObj *self){
3661 1 : msFreeOutputFormat( self );
3662 : }
3663 : SWIGINTERN void outputFormatObj_setExtension(outputFormatObj *self,char const *extension){
3664 0 : msFree( self->extension );
3665 0 : self->extension = msStrdup(extension);
3666 : }
3667 : SWIGINTERN void outputFormatObj_setMimetype(outputFormatObj *self,char const *mimetype){
3668 0 : msFree( self->mimetype );
3669 0 : self->mimetype = msStrdup(mimetype);
3670 : }
3671 : SWIGINTERN void outputFormatObj_setOption(outputFormatObj *self,char const *key,char const *value){
3672 0 : msSetOutputFormatOption( self, key, value );
3673 : }
3674 : SWIGINTERN int outputFormatObj_validate(outputFormatObj *self){
3675 0 : return msOutputFormatValidate(self, 0 );
3676 : }
3677 : SWIGINTERN char *outputFormatObj_getOption(outputFormatObj *self,char const *key,char const *value){
3678 0 : return msStrdup(msGetOutputFormatOption(self, key, value));
3679 : }
3680 : SWIGINTERN char *outputFormatObj_getOptionAt(outputFormatObj *self,int i){
3681 0 : if( i >= 0 && i < self->numformatoptions ) {
3682 0 : return msStrdup(self->formatoptions[i]);
3683 : }
3684 : return NULL;
3685 : }
3686 : SWIGINTERN void outputFormatObj_attachDevice(outputFormatObj *self,void *device){
3687 0 : self->device = device;
3688 : }
3689 : SWIGINTERN int queryMapObj_updateFromString(queryMapObj *self,char *snippet){
3690 0 : return msUpdateQueryMapFromString(self, snippet, 0);
3691 : }
3692 : SWIGINTERN char *queryMapObj_convertToString(queryMapObj *self){
3693 0 : return msWriteQueryMapToString(self);
3694 : }
3695 : SWIGINTERN webObj *new_webObj(void){
3696 : webObj *web;
3697 0 : web = (webObj *) malloc(sizeof(webObj));
3698 0 : initWeb(web);
3699 : return web;
3700 : }
3701 : SWIGINTERN void delete_webObj(webObj *self){
3702 0 : if (!self) return;
3703 0 : freeWeb(self);
3704 0 : free(self);
3705 : }
3706 : SWIGINTERN int webObj_updateFromString(webObj *self,char *snippet){
3707 0 : return msUpdateWebFromString(self, snippet, 0);
3708 : }
3709 : SWIGINTERN char *webObj_convertToString(webObj *self){
3710 0 : return msWriteWebToString(self);
3711 : }
3712 1 : SWIGINTERN struct styleObj *new_styleObj(classObj *parent_class){
3713 :
3714 : styleObj *style = NULL;
3715 :
3716 1 : if (parent_class!=NULL) {
3717 1 : if ((style = msGrowClassStyles(parent_class)) == NULL)
3718 : return NULL;
3719 :
3720 1 : if ( initStyle(style) == MS_FAILURE ) {
3721 0 : msSetError(12, "Failed to init new styleObj instance",
3722 : "initStyle()");
3723 : }
3724 1 : parent_class->numstyles++;
3725 1 : MS_REFCNT_INCR(style);
3726 : }
3727 : else {
3728 1 : style = (styleObj *) malloc(sizeof(styleObj));
3729 1 : if (!style) {
3730 0 : msSetError(2, "Failed to allocate memory for new styleObj instance",
3731 : "styleObj()");
3732 0 : return NULL;
3733 : }
3734 1 : if ( initStyle(style) == MS_FAILURE ) {
3735 0 : msSetError(12, "Failed to init new styleObj instance",
3736 : "initStyle()");
3737 0 : msFree(style);
3738 0 : return NULL;
3739 : }
3740 : }
3741 : return style;
3742 : }
3743 1 : SWIGINTERN void delete_styleObj(struct styleObj *self){
3744 1 : if (self) {
3745 1 : if ( freeStyle(self) == MS_SUCCESS ) {
3746 1 : free(self);
3747 : self=NULL;
3748 : }
3749 : }
3750 1 : }
3751 : SWIGINTERN int styleObj_updateFromString(struct styleObj *self,char *snippet){
3752 1 : return msUpdateStyleFromString(self, snippet, 0);
3753 : }
3754 : SWIGINTERN char *styleObj_convertToString(struct styleObj *self){
3755 1 : return msWriteStyleToString(self);
3756 : }
3757 1 : SWIGINTERN styleObj *styleObj_clone(struct styleObj *self){
3758 : styleObj *style;
3759 :
3760 1 : style = (styleObj *) malloc(sizeof(styleObj));
3761 1 : if (!style)
3762 : {
3763 0 : msSetError(2,
3764 : "Could not allocate memory for new styleObj instance",
3765 : "clone()");
3766 0 : return NULL;
3767 : }
3768 1 : if (initStyle(style) == -1)
3769 : {
3770 0 : msSetError(2, "Failed to initialize Style",
3771 : "clone()");
3772 0 : return NULL;
3773 : }
3774 :
3775 1 : if (msCopyStyle(style, self) != MS_SUCCESS)
3776 : {
3777 0 : free(style);
3778 0 : return NULL;
3779 : }
3780 :
3781 : return style;
3782 : }
3783 1 : SWIGINTERN int styleObj_setSymbolByName(struct styleObj *self,mapObj *map,char *symbolname){
3784 1 : self->symbol = msGetSymbolIndex(&map->symbolset, symbolname, 1);
3785 1 : if (self->symbolname) free((char*)self->symbolname);
3786 1 : if (symbolname) self->symbolname = msStrdup(symbolname);
3787 0 : else self->symbolname = 0;
3788 1 : return self->symbol;
3789 : }
3790 : SWIGINTERN int styleObj_removeBinding(struct styleObj *self,int binding){
3791 0 : if(binding < 0 || binding >= 12) return MS_FAILURE;
3792 :
3793 0 : if(self->bindings[binding].item) {
3794 0 : free(self->bindings[binding].item);
3795 0 : self->bindings[binding].item = NULL;
3796 0 : self->bindings[binding].index = -1;
3797 0 : self->numbindings--;
3798 : }
3799 :
3800 : return MS_SUCCESS;
3801 : }
3802 1 : SWIGINTERN int styleObj_setBinding(struct styleObj *self,int binding,char *item){
3803 1 : if(!item) return MS_FAILURE;
3804 1 : if(binding < 0 || binding >= 12) return MS_FAILURE;
3805 :
3806 1 : if(self->bindings[binding].item) {
3807 0 : free(self->bindings[binding].item);
3808 0 : self->bindings[binding].item = NULL;
3809 0 : self->bindings[binding].index = -1;
3810 0 : self->numbindings--;
3811 : }
3812 :
3813 1 : self->bindings[binding].item = msStrdup(item);
3814 1 : self->numbindings++;
3815 :
3816 1 : return MS_SUCCESS;
3817 : }
3818 : SWIGINTERN char *styleObj_getBinding(struct styleObj *self,int binding){
3819 1 : if(binding < 0 || binding >= 12) return NULL;
3820 :
3821 1 : return self->bindings[binding].item;
3822 : }
3823 : SWIGINTERN char *styleObj_getGeomTransform(struct styleObj *self){
3824 : return self->_geomtransform.string;
3825 : }
3826 : SWIGINTERN void styleObj_setGeomTransform(struct styleObj *self,char *transform){
3827 0 : msStyleSetGeomTransform(self, transform);
3828 : }
3829 1 : SWIGINTERN void styleObj_pattern_set(struct styleObj *self,int nListSize,double *pListValues){
3830 1 : if( nListSize < 2 )
3831 : {
3832 1 : msSetError(4, "Not enough pattern elements. A minimum of 2 are required", "pattern_set()");
3833 1 : return;
3834 : }
3835 1 : if( nListSize > 10 )
3836 : {
3837 1 : msSetError(12, "Too many elements", "pattern_set()");
3838 1 : return;
3839 : }
3840 1 : memcpy( self->pattern, pListValues, sizeof(double) * nListSize);
3841 1 : self->patternlength = nListSize;
3842 : }
3843 :
3844 : #define t_output_helper SWIG_Python_AppendOutput
3845 :
3846 :
3847 : static PyObject *
3848 1 : CreateTupleFromDoubleArray( double *first, unsigned int size ) {
3849 : unsigned int i;
3850 1 : PyObject *out = PyTuple_New( size );
3851 1 : for( i=0; i<size; i++ ) {
3852 1 : PyObject *val = PyFloat_FromDouble( *first );
3853 1 : ++first;
3854 1 : PyTuple_SetItem( out, i, val );
3855 : }
3856 1 : return out;
3857 : }
3858 :
3859 1 : SWIGINTERN void styleObj_pattern_get(struct styleObj *self,double **argout,int *pnListSize){
3860 1 : *pnListSize = self->patternlength;
3861 1 : *argout = (double*) malloc(sizeof(double) * *pnListSize);
3862 1 : memcpy( *argout, self->pattern, sizeof(double) * *pnListSize);
3863 1 : }
3864 :
3865 : SWIGINTERN int
3866 0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3867 : {
3868 0 : char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3869 0 : int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3870 0 : if (SWIG_IsOK(res)) {
3871 : /* special case of single char conversion when we don't need space for NUL */
3872 0 : if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3873 0 : if (csize <= size) {
3874 0 : if (val) {
3875 0 : if (csize) memcpy(val, cptr, csize*sizeof(char));
3876 0 : if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3877 : }
3878 0 : if (alloc == SWIG_NEWOBJ) {
3879 0 : free((char*)cptr);
3880 0 : res = SWIG_DelNewMask(res);
3881 : }
3882 : return res;
3883 : }
3884 0 : if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3885 : }
3886 : return SWIG_TypeError;
3887 : }
3888 :
3889 :
3890 : SWIGINTERN int
3891 0 : SWIG_AsVal_char (PyObject * obj, char *val)
3892 : {
3893 0 : int res = SWIG_AsCharArray(obj, val, 1);
3894 0 : if (!SWIG_IsOK(res)) {
3895 : long v;
3896 0 : res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3897 0 : if (SWIG_IsOK(res)) {
3898 0 : if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3899 0 : if (val) *val = (char)(v);
3900 : } else {
3901 : res = SWIG_OverflowError;
3902 : }
3903 : }
3904 : }
3905 0 : return res;
3906 : }
3907 :
3908 :
3909 : SWIGINTERNINLINE PyObject *
3910 : SWIG_From_char (char c)
3911 : {
3912 : return SWIG_FromCharPtrAndSize(&c,1);
3913 : }
3914 :
3915 1 : SWIGINTERN struct labelObj *new_labelObj(void){
3916 : labelObj *label;
3917 :
3918 1 : label = (labelObj *)calloc(1, sizeof(labelObj));
3919 1 : if (!label)
3920 : return(NULL);
3921 :
3922 1 : initLabel(label);
3923 :
3924 1 : return(label);
3925 : }
3926 : SWIGINTERN void delete_labelObj(struct labelObj *self){
3927 1 : freeLabel(self);
3928 : }
3929 : SWIGINTERN int labelObj_updateFromString(struct labelObj *self,char *snippet){
3930 0 : return msUpdateLabelFromString(self, snippet,0);
3931 : }
3932 : SWIGINTERN char *labelObj_convertToString(struct labelObj *self){
3933 0 : return msWriteLabelToString(self);
3934 : }
3935 : SWIGINTERN int labelObj_removeBinding(struct labelObj *self,int binding){
3936 0 : if(binding < 0 || binding >= 12) return MS_FAILURE;
3937 :
3938 0 : if(self->bindings[binding].item) {
3939 0 : free(self->bindings[binding].item);
3940 0 : self->bindings[binding].item = NULL;
3941 0 : self->bindings[binding].index = -1;
3942 0 : self->numbindings--;
3943 : }
3944 :
3945 : return MS_SUCCESS;
3946 : }
3947 : SWIGINTERN char *labelObj_getBinding(struct labelObj *self,int binding){
3948 1 : if(binding < 0 || binding >= 12) return NULL;
3949 :
3950 1 : return self->bindings[binding].item;
3951 : }
3952 1 : SWIGINTERN int labelObj_setBinding(struct labelObj *self,int binding,char *item){
3953 1 : if(!item) return MS_FAILURE;
3954 1 : if(binding < 0 || binding >= 12) return MS_FAILURE;
3955 :
3956 1 : if(self->bindings[binding].item) {
3957 0 : free(self->bindings[binding].item);
3958 0 : self->bindings[binding].item = NULL;
3959 0 : self->bindings[binding].index = -1;
3960 0 : self->numbindings--;
3961 : }
3962 :
3963 1 : self->bindings[binding].item = msStrdup(item);
3964 1 : self->numbindings++;
3965 :
3966 1 : return MS_SUCCESS;
3967 : }
3968 0 : SWIGINTERN int labelObj_setExpression(struct labelObj *self,char *expression){
3969 0 : if (!expression || strlen(expression) == 0) {
3970 0 : msFreeExpression(&self->expression);
3971 0 : return MS_SUCCESS;
3972 : }
3973 0 : else return msLoadExpressionString(&self->expression, expression);
3974 : }
3975 : SWIGINTERN char *labelObj_getExpressionString(struct labelObj *self){
3976 0 : return msGetExpressionString(&(self->expression));
3977 : }
3978 0 : SWIGINTERN int labelObj_setText(struct labelObj *self,char *text){
3979 0 : if (!text || strlen(text) == 0) {
3980 0 : msFreeExpression(&self->text);
3981 0 : return MS_SUCCESS;
3982 : }
3983 0 : else return msLoadExpressionString(&self->text, text);
3984 : }
3985 : SWIGINTERN char *labelObj_getTextString(struct labelObj *self){
3986 0 : return msGetExpressionString(&(self->text));
3987 : }
3988 0 : SWIGINTERN styleObj *labelObj_getStyle(struct labelObj *self,int i){
3989 0 : if (i >= 0 && i < self->numstyles) {
3990 0 : MS_REFCNT_INCR(self->styles[i]);
3991 0 : return self->styles[i];
3992 : } else {
3993 0 : msSetError(31, "Invalid index: %d", "getStyle()", i);
3994 : return NULL;
3995 : }
3996 : }
3997 : SWIGINTERN int labelObj_insertStyle(struct labelObj *self,styleObj *style,int index){
3998 0 : return msInsertLabelStyle(self, style, index);
3999 : }
4000 0 : SWIGINTERN styleObj *labelObj_removeStyle(struct labelObj *self,int index){
4001 0 : styleObj* style = (styleObj *) msRemoveLabelStyle(self, index);
4002 0 : if (style)
4003 0 : MS_REFCNT_INCR(style);
4004 0 : return style;
4005 : }
4006 : SWIGINTERN int labelObj_moveStyleUp(struct labelObj *self,int index){
4007 0 : return msMoveLabelStyleUp(self, index);
4008 : }
4009 : SWIGINTERN int labelObj_moveStyleDown(struct labelObj *self,int index){
4010 0 : return msMoveLabelStyleDown(self, index);
4011 : }
4012 1 : SWIGINTERN struct classObj *new_classObj(layerObj *layer){
4013 : classObj *new_class=NULL;
4014 :
4015 1 : if (!layer)
4016 : {
4017 1 : new_class = (classObj *) malloc(sizeof(classObj));
4018 1 : if (!new_class)
4019 : {
4020 0 : msSetError(2,
4021 : "Could not allocate memory for new classObj instance",
4022 : "classObj()");
4023 0 : return NULL;
4024 : }
4025 1 : if (initClass(new_class) == -1) return NULL;
4026 1 : new_class->layer = NULL;
4027 1 : return new_class;
4028 : }
4029 : else
4030 : {
4031 1 : if(msGrowLayerClasses(layer) == NULL)
4032 : return NULL;
4033 1 : if (initClass(layer->class[layer->numclasses]) == -1)
4034 : return NULL;
4035 1 : layer->class[layer->numclasses]->layer = layer;
4036 1 : MS_REFCNT_INCR(layer->class[layer->numclasses]);
4037 1 : layer->numclasses++;
4038 1 : return (layer->class[layer->numclasses-1]);
4039 : }
4040 :
4041 : return NULL;
4042 : }
4043 1 : SWIGINTERN void delete_classObj(struct classObj *self){
4044 1 : if (self)
4045 : {
4046 1 : if (freeClass(self)==MS_SUCCESS) {
4047 1 : free(self);
4048 : self=NULL;
4049 : }
4050 : }
4051 1 : }
4052 : SWIGINTERN int classObj_updateFromString(struct classObj *self,char *snippet){
4053 0 : return msUpdateClassFromString(self, snippet, 0);
4054 : }
4055 : SWIGINTERN char *classObj_convertToString(struct classObj *self){
4056 0 : return msWriteClassToString(self);
4057 : }
4058 1 : SWIGINTERN classObj *classObj_clone(struct classObj *self){
4059 : classObj *new_class;
4060 :
4061 1 : new_class = (classObj *) malloc(sizeof(classObj));
4062 1 : if (!new_class)
4063 : {
4064 0 : msSetError(2,
4065 : "Could not allocate memory for new classObj instance",
4066 : "clone()");
4067 0 : return NULL;
4068 : }
4069 1 : if (initClass(new_class) == -1)
4070 : {
4071 0 : msSetError(2, "Failed to initialize Class",
4072 : "clone()");
4073 0 : return NULL;
4074 : }
4075 1 : new_class->layer = NULL;
4076 :
4077 1 : if (msCopyClass(new_class, self, self->layer) != MS_SUCCESS) {
4078 0 : freeClass(new_class);
4079 0 : free(new_class);
4080 : new_class = NULL;
4081 : }
4082 :
4083 : return new_class;
4084 : }
4085 0 : SWIGINTERN int classObj_setExpression(struct classObj *self,char *expression){
4086 0 : if (!expression || strlen(expression) == 0) {
4087 0 : msFreeExpression(&self->expression);
4088 0 : return MS_SUCCESS;
4089 : }
4090 0 : else return msLoadExpressionString(&self->expression, expression);
4091 : }
4092 : SWIGINTERN char *classObj_getExpressionString(struct classObj *self){
4093 0 : return msGetExpressionString(&(self->expression));
4094 : }
4095 0 : SWIGINTERN int classObj_setText(struct classObj *self,char *text){
4096 0 : if (!text || strlen(text) == 0) {
4097 0 : msFreeExpression(&self->text);
4098 0 : return MS_SUCCESS;
4099 : }
4100 0 : else return msLoadExpressionString(&self->text, text);
4101 : }
4102 : SWIGINTERN char *classObj_getTextString(struct classObj *self){
4103 0 : return msGetExpressionString(&(self->text));
4104 : }
4105 0 : SWIGINTERN char *classObj_getMetaData(struct classObj *self,char *name){
4106 : char *value = NULL;
4107 0 : if (!name) {
4108 0 : msSetError(16, "NULL key", "getMetaData");
4109 : }
4110 :
4111 0 : value = (char *) msLookupHashTable(&(self->metadata), name);
4112 0 : if (!value) {
4113 0 : msSetError(16, "Key %s does not exist", "getMetaData", name);
4114 0 : return NULL;
4115 : }
4116 : return value;
4117 : }
4118 : SWIGINTERN int classObj_setMetaData(struct classObj *self,char *name,char *value){
4119 0 : if (msInsertHashTable(&(self->metadata), name, value) == NULL)
4120 : return MS_FAILURE;
4121 : return MS_SUCCESS;
4122 : }
4123 : SWIGINTERN char *classObj_getFirstMetaDataKey(struct classObj *self){
4124 1 : return (char *) msFirstKeyFromHashTable(&(self->metadata));
4125 : }
4126 : SWIGINTERN char *classObj_getNextMetaDataKey(struct classObj *self,char *lastkey){
4127 1 : return (char *) msNextKeyFromHashTable(&(self->metadata), lastkey);
4128 : }
4129 0 : SWIGINTERN int classObj_drawLegendIcon(struct classObj *self,mapObj *map,layerObj *layer,int width,int height,imageObj *dstImage,int dstX,int dstY){
4130 0 : if(layer->sizeunits != MS_PIXELS) {
4131 0 : map->cellsize = msAdjustExtent(&(map->extent), map->width, map->height);
4132 0 : layer->scalefactor = (msInchesPerUnit(layer->sizeunits,0)/msInchesPerUnit(map->units,0)) / map->cellsize;
4133 : }
4134 : else
4135 0 : layer->scalefactor = map->resolution/map->defresolution;
4136 :
4137 0 : return msDrawLegendIcon(map, layer, self, width, height, dstImage, dstX, dstY, 1, NULL);
4138 : }
4139 : SWIGINTERN imageObj *classObj_createLegendIcon(struct classObj *self,mapObj *map,layerObj *layer,int width,int height){
4140 1 : return msCreateLegendIcon(map, layer, self, width, height, 1);
4141 : }
4142 1 : SWIGINTERN labelObj *classObj_getLabel(struct classObj *self,int i){
4143 1 : if (i >= 0 && i < self->numlabels) {
4144 1 : MS_REFCNT_INCR(self->labels[i]);
4145 1 : return self->labels[i];
4146 : } else {
4147 0 : msSetError(31, "Invalid index: %d.", "getLabel()", i);
4148 : return NULL;
4149 : }
4150 : }
4151 : SWIGINTERN int classObj_addLabel(struct classObj *self,labelObj *label){
4152 1 : return msAddLabelToClass(self, label);
4153 : }
4154 0 : SWIGINTERN labelObj *classObj_removeLabel(struct classObj *self,int index){
4155 0 : labelObj* label = (labelObj *) msRemoveLabelFromClass(self, index);
4156 0 : if (label) MS_REFCNT_INCR(label);
4157 0 : return label;
4158 : }
4159 1 : SWIGINTERN styleObj *classObj_getStyle(struct classObj *self,int i){
4160 1 : if (i >= 0 && i < self->numstyles) {
4161 1 : MS_REFCNT_INCR(self->styles[i]);
4162 1 : return self->styles[i];
4163 : } else {
4164 0 : msSetError(31, "Invalid index: %d", "getStyle()", i);
4165 : return NULL;
4166 : }
4167 : }
4168 : SWIGINTERN int classObj_insertStyle(struct classObj *self,styleObj *style,int index){
4169 1 : return msInsertStyle(self, style, index);
4170 : }
4171 1 : SWIGINTERN styleObj *classObj_removeStyle(struct classObj *self,int index){
4172 1 : styleObj* style = (styleObj *) msRemoveStyle(self, index);
4173 1 : if (style) MS_REFCNT_INCR(style);
4174 1 : return style;
4175 : }
4176 : SWIGINTERN int classObj_moveStyleUp(struct classObj *self,int index){
4177 0 : return msMoveStyleUp(self, index);
4178 : }
4179 : SWIGINTERN int classObj_moveStyleDown(struct classObj *self,int index){
4180 0 : return msMoveStyleDown(self, index);
4181 : }
4182 : SWIGINTERN void labelCacheObj_freeCache(labelCacheObj *self){
4183 0 : msFreeLabelCache(self);
4184 : }
4185 :
4186 : #define SWIG_From_long PyInt_FromLong
4187 :
4188 : SWIGINTERN resultObj *new_resultObj(long shapeindex){
4189 0 : resultObj *result = (resultObj *) msSmallMalloc(sizeof(resultObj));
4190 :
4191 0 : result->tileindex = -1;
4192 0 : result->resultindex = -1;
4193 0 : result->shapeindex = shapeindex;
4194 :
4195 : return result;
4196 : }
4197 : SWIGINTERN void delete_resultObj(resultObj *self){
4198 0 : free(self);
4199 : }
4200 : SWIGINTERN resultObj *resultCacheObj_getResult(resultCacheObj *self,int i){
4201 1 : if (i >= 0 && i < self->numresults) {
4202 1 : return &self->results[i];
4203 : }
4204 : return NULL;
4205 : }
4206 1 : SWIGINTERN symbolSetObj *new_symbolSetObj(char const *symbolfile){
4207 : symbolSetObj *symbolset;
4208 : mapObj *temp_map=NULL;
4209 1 : symbolset = (symbolSetObj *) malloc(sizeof(symbolSetObj));
4210 1 : msInitSymbolSet(symbolset);
4211 1 : if (symbolfile) {
4212 1 : symbolset->filename = msStrdup(symbolfile);
4213 1 : temp_map = msNewMapObj();
4214 1 : msLoadSymbolSet(symbolset, temp_map);
4215 1 : symbolset->map = NULL;
4216 1 : msFreeMap(temp_map);
4217 : }
4218 1 : return symbolset;
4219 : }
4220 1 : SWIGINTERN void delete_symbolSetObj(symbolSetObj *self){
4221 1 : msFreeSymbolSet(self);
4222 1 : if (self->filename) free(self->filename);
4223 1 : free(self);
4224 1 : }
4225 : SWIGINTERN symbolObj *symbolSetObj_getSymbol(symbolSetObj *self,int i){
4226 1 : if (i >= 0 && i < self->numsymbols) {
4227 1 : symbolObj *s=self->symbol[i];
4228 1 : MS_REFCNT_INCR(s);
4229 : return s;
4230 : } else
4231 : return NULL;
4232 : }
4233 1 : SWIGINTERN symbolObj *symbolSetObj_getSymbolByName(symbolSetObj *self,char *symbolname){
4234 : int i;
4235 :
4236 1 : if (!symbolname) return NULL;
4237 :
4238 1 : i = msGetSymbolIndex(self, symbolname, 1);
4239 1 : if (i == -1)
4240 : return NULL;
4241 : else {
4242 1 : MS_REFCNT_INCR(self->symbol[i]);
4243 1 : return self->symbol[i];
4244 : }
4245 : }
4246 : SWIGINTERN int symbolSetObj_index(symbolSetObj *self,char *symbolname){
4247 1 : return msGetSymbolIndex(self, symbolname, 1);
4248 : }
4249 : SWIGINTERN int symbolSetObj_appendSymbol(symbolSetObj *self,symbolObj *symbol){
4250 1 : return msAppendSymbol(self, symbol);
4251 : }
4252 1 : SWIGINTERN symbolObj *symbolSetObj_removeSymbol(symbolSetObj *self,int index){
4253 1 : symbolObj *s=msRemoveSymbol(self, index);
4254 1 : if (s!=NULL) {
4255 1 : MS_REFCNT_INCR(s);
4256 : }
4257 1 : return s;
4258 : }
4259 : SWIGINTERN int symbolSetObj_save(symbolSetObj *self,char const *filename){
4260 1 : return msSaveSymbolSet(self, filename);
4261 : }
4262 : SWIGINTERN int referenceMapObj_updateFromString(referenceMapObj *self,char *snippet){
4263 0 : return msUpdateReferenceMapFromString(self, snippet, 0);
4264 : }
4265 : SWIGINTERN char *referenceMapObj_convertToString(referenceMapObj *self){
4266 0 : return msWriteReferenceMapToString(self);
4267 : }
4268 : SWIGINTERN int scalebarObj_updateFromString(scalebarObj *self,char *snippet){
4269 0 : return msUpdateScalebarFromString(self, snippet, 0);
4270 : }
4271 : SWIGINTERN char *scalebarObj_convertToString(scalebarObj *self){
4272 0 : return msWriteScalebarToString(self);
4273 : }
4274 : SWIGINTERN int legendObj_updateFromString(legendObj *self,char *snippet){
4275 0 : return msUpdateLegendFromString(self, snippet, 0);
4276 : }
4277 : SWIGINTERN char *legendObj_convertToString(legendObj *self){
4278 0 : return msWriteLegendToString(self);
4279 : }
4280 1 : SWIGINTERN struct imageObj *new_imageObj(int width,int height,outputFormatObj *input_format,char const *file,double resolution,double defresolution){
4281 : imageObj *image=NULL;
4282 : outputFormatObj *format;
4283 : rendererVTableObj *renderer = NULL;
4284 : rasterBufferObj *rb = NULL;
4285 :
4286 1 : if (input_format) {
4287 : format = input_format;
4288 : }
4289 : else {
4290 1 : format = msCreateDefaultOutputFormat(NULL, "AGG/PNG", "aggpng");
4291 1 : if (format)
4292 1 : msInitializeRendererVTable(format);
4293 : }
4294 1 : if (format == NULL) {
4295 0 : msSetError(15, "Could not create output format",
4296 : "imageObj()");
4297 0 : return NULL;
4298 : }
4299 :
4300 1 : if (file) {
4301 :
4302 0 : renderer = format->vtable;
4303 0 : rb = (rasterBufferObj*) malloc(sizeof(rasterBufferObj));
4304 0 : if (!rb) {
4305 0 : msSetError(2, NULL, "imageObj()");
4306 0 : return NULL;
4307 : }
4308 0 : if ( (renderer->loadImageFromFile((char *)file, rb)) == MS_FAILURE) {
4309 0 : msFreeRasterBuffer(rb);
4310 0 : free(rb);
4311 0 : return NULL;
4312 : }
4313 0 : image = msImageCreate(rb->width, rb->height, format, NULL, NULL,
4314 : resolution, defresolution, NULL);
4315 0 : if (! image) {
4316 0 : msFreeRasterBuffer(rb);
4317 0 : free(rb);
4318 0 : return NULL;
4319 : }
4320 :
4321 0 : if(renderer->mergeRasterBuffer(image, rb, 1.0, 0, 0, 0, 0, rb->width, rb->height) != MS_SUCCESS) {
4322 0 : msFreeImage(image);
4323 : image = NULL;
4324 : }
4325 :
4326 0 : msFreeRasterBuffer(rb);
4327 0 : free(rb);
4328 :
4329 0 : return image;
4330 : }
4331 :
4332 1 : image = msImageCreate(width, height, format, NULL, NULL, resolution, defresolution, NULL);
4333 1 : return image;
4334 : }
4335 : SWIGINTERN void delete_imageObj(struct imageObj *self){
4336 1 : msFreeImage(self);
4337 : }
4338 : SWIGINTERN void imageObj_save(struct imageObj *self,char *filename,mapObj *map){
4339 1 : msSaveImage(map, self, filename );
4340 : }
4341 1 : SWIGINTERN gdBuffer imageObj_getBytes(struct imageObj *self){
4342 : gdBuffer buffer;
4343 :
4344 1 : buffer.owns_data = 1;
4345 :
4346 1 : buffer.data = msSaveImageBuffer(self, &buffer.size, self->format);
4347 :
4348 1 : if( buffer.data == NULL || buffer.size == 0 )
4349 : {
4350 0 : buffer.data = NULL;
4351 0 : msSetError(12, "Failed to get image buffer", "getBytes");
4352 0 : return buffer;
4353 : }
4354 :
4355 1 : return buffer;
4356 : }
4357 0 : SWIGINTERN int imageObj_getSize(struct imageObj *self){
4358 : gdBuffer buffer;
4359 : int size=0;
4360 :
4361 0 : buffer.data = msSaveImageBuffer(self, &buffer.size, self->format);
4362 0 : size = buffer.size;
4363 :
4364 0 : if( buffer.data == NULL || buffer.size == 0 ) {
4365 0 : buffer.data = NULL;
4366 0 : msSetError(12, "Failed to get image buffer size", "getSize");
4367 : }
4368 0 : free(buffer.data);
4369 0 : return size;
4370 : }
4371 1 : SWIGINTERN int imageObj_write(struct imageObj *self,PyObject *file){
4372 : unsigned char *imgbuffer=NULL;
4373 : int imgsize;
4374 : PyObject *noerr;
4375 : int retval=MS_FAILURE;
4376 :
4377 : /* Return immediately if image driver is not GD */
4378 1 : if ( !MS_RENDERER_PLUGIN(self->format) )
4379 : {
4380 0 : msSetError(15, "Writing of %s format not implemented",
4381 : "imageObj::write", self->format->driver);
4382 0 : return MS_FAILURE;
4383 : }
4384 :
4385 1 : if (file == Py_None) /* write to stdout */
4386 0 : retval = msSaveImage(NULL, self, NULL);
4387 : else /* presume a Python file-like object */
4388 : {
4389 1 : imgbuffer = msSaveImageBuffer(self, &imgsize,
4390 : self->format);
4391 1 : if (imgsize == 0)
4392 : {
4393 0 : msSetError(15, "failed to get image buffer", "write()");
4394 0 : return MS_FAILURE;
4395 : }
4396 :
4397 : #if PY_MAJOR_VERSION >= 3
4398 : // https://docs.python.org/3/c-api/arg.html
4399 1 : noerr = PyObject_CallMethod(file, "write", "y#", imgbuffer, imgsize);
4400 : #else
4401 : // https://docs.python.org/2/c-api/arg.html
4402 : noerr = PyObject_CallMethod(file, "write", "s#", imgbuffer, imgsize);
4403 : #endif
4404 :
4405 1 : free(imgbuffer);
4406 1 : if (noerr == NULL)
4407 : return MS_FAILURE;
4408 : else
4409 1 : Py_DECREF(noerr);
4410 : retval = MS_SUCCESS;
4411 : }
4412 :
4413 : return retval;
4414 : }
4415 1 : SWIGINTERN PyObject *imageObj_saveToString(struct imageObj *self){
4416 1 : int size=0;
4417 : unsigned char *imgbytes;
4418 : PyObject *imgstring;
4419 :
4420 1 : imgbytes = msSaveImageBuffer(self, &size, self->format);
4421 1 : if (size == 0)
4422 : {
4423 0 : msSetError(15, "failed to get image buffer", "saveToString()");
4424 0 : return NULL;
4425 : }
4426 1 : imgstring = PyBytes_FromStringAndSize((const char*) imgbytes, size);
4427 1 : free(imgbytes);
4428 1 : return imgstring;
4429 : }
4430 1 : SWIGINTERN struct layerObj *new_layerObj(mapObj *map){
4431 : layerObj *layer;
4432 : int result;
4433 :
4434 1 : if (!map) {
4435 1 : layer = (layerObj *) malloc(sizeof(layerObj));
4436 1 : if (!layer) {
4437 0 : msSetError(2, "Failed to initialize Layer",
4438 : "layerObj()");
4439 0 : return NULL;
4440 : }
4441 1 : result = initLayer(layer, NULL);
4442 1 : if (result == MS_SUCCESS) {
4443 1 : layer->index = -1;
4444 1 : return layer;
4445 : }
4446 : else {
4447 0 : msSetError(2, "Failed to initialize Layer",
4448 : "layerObj()");
4449 0 : return NULL;
4450 : }
4451 : }
4452 : else {
4453 1 : if(msGrowMapLayers(map) == NULL)
4454 : return(NULL);
4455 :
4456 1 : if (initLayer((map->layers[map->numlayers]), map) == -1)
4457 : return(NULL);
4458 :
4459 1 : map->layers[map->numlayers]->index = map->numlayers;
4460 1 : map->layerorder[map->numlayers] = map->numlayers;
4461 1 : map->numlayers++;
4462 1 : MS_REFCNT_INCR(map->layers[map->numlayers-1]);
4463 :
4464 1 : return (map->layers[map->numlayers-1]);
4465 : }
4466 : }
4467 : SWIGINTERN void layerObj_setOpacity(struct layerObj *self,int opacity){
4468 0 : msSetLayerOpacity(self, opacity);
4469 : }
4470 : SWIGINTERN int layerObj_getOpacity(struct layerObj *self){
4471 0 : if(self->compositer) return (self->compositer->opacity);
4472 : return (100);
4473 : }
4474 1 : SWIGINTERN void delete_layerObj(struct layerObj *self){
4475 : /*if (!self->map) {*/
4476 1 : if (self) {
4477 1 : if(freeLayer(self)==MS_SUCCESS) {
4478 1 : free(self);
4479 : }
4480 : }
4481 1 : }
4482 1 : SWIGINTERN layerObj *layerObj_clone(struct layerObj *self){
4483 : layerObj *layer;
4484 : int result;
4485 :
4486 1 : layer = (layerObj *) malloc(sizeof(layerObj));
4487 1 : if (!layer) {
4488 0 : msSetError(2, "Failed to initialize Layer",
4489 : "layerObj()");
4490 0 : return NULL;
4491 : }
4492 1 : result = initLayer(layer, NULL);
4493 1 : if (result != MS_SUCCESS) {
4494 0 : msSetError(2, "Failed to initialize Layer",
4495 : "layerObj()");
4496 0 : return NULL;
4497 : }
4498 :
4499 1 : if (msCopyLayer(layer, self) != MS_SUCCESS) {
4500 0 : freeLayer(layer);
4501 0 : free(layer);
4502 : layer = NULL;
4503 : }
4504 1 : layer->map = NULL;
4505 1 : layer->index = -1;
4506 :
4507 1 : return layer;
4508 : }
4509 : SWIGINTERN int layerObj_updateFromString(struct layerObj *self,char *snippet){
4510 1 : return msUpdateLayerFromString(self, snippet, 0);
4511 : }
4512 : SWIGINTERN char *layerObj_convertToString(struct layerObj *self){
4513 0 : return msWriteLayerToString(self);
4514 : }
4515 : SWIGINTERN int layerObj_insertClass(struct layerObj *self,classObj *classobj,int index){
4516 1 : return msInsertClass(self, classobj, index);
4517 : }
4518 1 : SWIGINTERN classObj *layerObj_removeClass(struct layerObj *self,int index){
4519 1 : classObj* c = msRemoveClass(self, index);
4520 1 : if (c != NULL) {
4521 1 : MS_REFCNT_INCR(c);
4522 : }
4523 1 : return c;
4524 : }
4525 1 : SWIGINTERN int layerObj_open(struct layerObj *self){
4526 : int status;
4527 1 : status = msLayerOpen(self);
4528 1 : if (status == MS_SUCCESS) {
4529 1 : return msLayerGetItems(self);
4530 : }
4531 : return status;
4532 : }
4533 0 : SWIGINTERN int layerObj_whichShapes(struct layerObj *self,rectObj rect){
4534 0 : int oldconnectiontype = self->connectiontype;
4535 0 : self->connectiontype = MS_INLINE;
4536 :
4537 0 : if(msLayerWhichItems(self, 1, NULL) != MS_SUCCESS) {
4538 0 : self->connectiontype = oldconnectiontype;
4539 0 : return MS_FAILURE;
4540 : }
4541 0 : self->connectiontype = oldconnectiontype;
4542 :
4543 0 : return msLayerWhichShapes(self, rect, 0);
4544 : }
4545 0 : SWIGINTERN shapeObj *layerObj_nextShape(struct layerObj *self){
4546 : int status;
4547 : shapeObj *shape;
4548 :
4549 0 : shape = (shapeObj *)malloc(sizeof(shapeObj));
4550 0 : if (!shape) return NULL;
4551 0 : msInitShape(shape);
4552 :
4553 0 : status = msLayerNextShape(self, shape);
4554 0 : if(status != MS_SUCCESS) {
4555 0 : msFreeShape(shape);
4556 0 : free(shape);
4557 0 : return NULL;
4558 : } else
4559 : return shape;
4560 : }
4561 : SWIGINTERN void layerObj_close(struct layerObj *self){
4562 1 : msLayerClose(self);
4563 : }
4564 1 : SWIGINTERN shapeObj *layerObj_getShape(struct layerObj *self,resultObj *record){
4565 : int retval;
4566 : shapeObj *shape;
4567 :
4568 1 : if (!record) return NULL;
4569 :
4570 1 : shape = (shapeObj *)malloc(sizeof(shapeObj));
4571 1 : if (!shape) return NULL;
4572 :
4573 1 : msInitShape(shape);
4574 1 : shape->type = self->type; /* is this right? */
4575 :
4576 1 : retval = msLayerGetShape(self, shape, record);
4577 1 : if(retval != MS_SUCCESS) {
4578 0 : msFreeShape(shape);
4579 0 : free(shape);
4580 0 : return NULL;
4581 : } else
4582 : return shape;
4583 : }
4584 : SWIGINTERN int layerObj_getNumResults(struct layerObj *self){
4585 1 : if (!self->resultcache) return 0;
4586 1 : return self->resultcache->numresults;
4587 : }
4588 0 : SWIGINTERN rectObj *layerObj_getResultsBounds(struct layerObj *self){
4589 : rectObj *bounds;
4590 0 : if (!self->resultcache) return NULL;
4591 0 : bounds = (rectObj *) malloc(sizeof(rectObj));
4592 0 : MS_COPYRECT(bounds, &self->resultcache->bounds);
4593 : return bounds;
4594 : }
4595 : SWIGINTERN resultObj *layerObj_getResult(struct layerObj *self,int i){
4596 1 : if (!self->resultcache) return NULL;
4597 1 : if (i >= 0 && i < self->resultcache->numresults)
4598 1 : return &self->resultcache->results[i];
4599 : else
4600 : return NULL;
4601 : }
4602 : SWIGINTERN classObj *layerObj_getClass(struct layerObj *self,int i){
4603 : classObj *result=NULL;
4604 1 : if (i >= 0 && i < self->numclasses) {
4605 1 : result=self->class[i];
4606 1 : MS_REFCNT_INCR(result);
4607 : }
4608 : return result;
4609 : }
4610 : SWIGINTERN char *layerObj_getItem(struct layerObj *self,int i){
4611 :
4612 1 : if (i >= 0 && i < self->numitems)
4613 1 : return (char *) (self->items[i]);
4614 : else
4615 : return NULL;
4616 : }
4617 : SWIGINTERN int layerObj_setItems(struct layerObj *self,char **items,int numitems){
4618 0 : return msLayerSetItems(self, items, numitems);
4619 : }
4620 : SWIGINTERN int layerObj_draw(struct layerObj *self,mapObj *map,imageObj *image){
4621 0 : return msDrawLayer(map, self, image);
4622 : }
4623 : SWIGINTERN int layerObj_drawQuery(struct layerObj *self,mapObj *map,imageObj *image){
4624 0 : return msDrawQueryLayer(map, self, image);
4625 : }
4626 0 : SWIGINTERN int layerObj_queryByFilter(struct layerObj *self,mapObj *map,char *string){
4627 : int status;
4628 : int retval;
4629 :
4630 0 : msInitQuery(&(map->query));
4631 :
4632 0 : map->query.type = MS_QUERY_BY_FILTER;
4633 0 : map->query.mode = MS_QUERY_MULTIPLE;
4634 :
4635 0 : map->query.filter.string = msStrdup(string);
4636 0 : map->query.filter.type = MS_EXPRESSION;
4637 :
4638 0 : map->query.layer = self->index;
4639 0 : map->query.rect = map->extent;
4640 :
4641 0 : status = self->status;
4642 0 : self->status = 1;
4643 0 : retval = msQueryByFilter(map);
4644 0 : self->status = status;
4645 0 : return retval;
4646 : }
4647 1 : SWIGINTERN int layerObj_queryByAttributes(struct layerObj *self,mapObj *map,char *qitem,char *qstring,int mode){
4648 : int status;
4649 : int retval;
4650 :
4651 1 : msInitQuery(&(map->query));
4652 :
4653 1 : map->query.type = MS_QUERY_BY_FILTER;
4654 1 : map->query.mode = mode;
4655 :
4656 1 : if(qitem) map->query.filteritem = msStrdup(qitem);
4657 1 : if(qstring) {
4658 1 : msInitExpression(&map->query.filter);
4659 1 : msLoadExpressionString(&map->query.filter, qstring);
4660 : }
4661 :
4662 1 : map->query.layer = self->index;
4663 1 : map->query.rect = map->extent;
4664 :
4665 1 : status = self->status;
4666 1 : self->status = 1;
4667 1 : retval = msQueryByFilter(map);
4668 1 : self->status = status;
4669 :
4670 1 : return retval;
4671 : }
4672 : SWIGINTERN int layerObj_queryByPoint(struct layerObj *self,mapObj *map,pointObj *point,int mode,double buffer){
4673 : int status;
4674 : int retval;
4675 :
4676 1 : msInitQuery(&(map->query));
4677 :
4678 1 : map->query.type = MS_QUERY_BY_POINT;
4679 1 : map->query.mode = mode;
4680 1 : map->query.point = *point;
4681 1 : map->query.buffer = buffer;
4682 1 : map->query.layer = self->index;
4683 :
4684 1 : status = self->status;
4685 1 : self->status = 1;
4686 1 : retval = msQueryByPoint(map);
4687 1 : self->status = status;
4688 :
4689 : return retval;
4690 : }
4691 : SWIGINTERN int layerObj_queryByRect(struct layerObj *self,mapObj *map,rectObj rect){
4692 : int status;
4693 : int retval;
4694 :
4695 1 : msInitQuery(&(map->query));
4696 :
4697 1 : map->query.type = MS_QUERY_BY_RECT;
4698 1 : map->query.mode = MS_QUERY_MULTIPLE;
4699 1 : map->query.rect = rect;
4700 1 : map->query.layer = self->index;
4701 :
4702 1 : status = self->status;
4703 1 : self->status = 1;
4704 1 : retval = msQueryByRect(map);
4705 1 : self->status = status;
4706 :
4707 : return retval;
4708 : }
4709 : SWIGINTERN int layerObj_queryByFeatures(struct layerObj *self,mapObj *map,int slayer){
4710 : int status;
4711 : int retval;
4712 :
4713 0 : map->query.slayer = slayer;
4714 0 : map->query.layer = self->index;
4715 :
4716 0 : status = self->status;
4717 0 : self->status = 1;
4718 0 : retval = msQueryByFeatures(map);
4719 0 : self->status = status;
4720 : return retval;
4721 : }
4722 1 : SWIGINTERN int layerObj_queryByShape(struct layerObj *self,mapObj *map,shapeObj *shape){
4723 : int status;
4724 : int retval;
4725 :
4726 1 : msInitQuery(&(map->query));
4727 :
4728 1 : map->query.type = MS_QUERY_BY_SHAPE;
4729 1 : map->query.mode = MS_QUERY_MULTIPLE;
4730 1 : map->query.shape = (shapeObj *) malloc(sizeof(shapeObj));
4731 1 : msInitShape(map->query.shape);
4732 1 : msCopyShape(shape, map->query.shape);
4733 1 : map->query.layer = self->index;
4734 :
4735 1 : status = self->status;
4736 1 : self->status = 1;
4737 1 : retval = msQueryByShape(map);
4738 1 : self->status = status;
4739 1 : return retval;
4740 : }
4741 : SWIGINTERN int layerObj_queryByIndex(struct layerObj *self,mapObj *map,int tileindex,int shapeindex,int bAddToQuery){
4742 : int status;
4743 : int retval;
4744 :
4745 1 : msInitQuery(&(map->query));
4746 :
4747 1 : map->query.type = MS_QUERY_BY_INDEX;
4748 1 : map->query.mode = MS_QUERY_SINGLE;
4749 1 : map->query.tileindex = tileindex;
4750 1 : map->query.shapeindex = shapeindex;
4751 1 : map->query.clear_resultcache = !bAddToQuery;
4752 1 : map->query.layer = self->index;
4753 :
4754 1 : status = self->status;
4755 1 : self->status = 1;
4756 1 : retval = msQueryByIndex(map);
4757 1 : self->status = status;
4758 : return retval;
4759 : }
4760 : SWIGINTERN resultCacheObj *layerObj_getResults(struct layerObj *self){
4761 : return self->resultcache;
4762 : }
4763 1 : SWIGINTERN int layerObj_setFilter(struct layerObj *self,char *filter){
4764 1 : if (!filter || strlen(filter) == 0) {
4765 1 : msFreeExpression(&self->filter);
4766 1 : return MS_SUCCESS;
4767 : }
4768 1 : else return msLoadExpressionString(&self->filter, filter);
4769 : }
4770 : SWIGINTERN char *layerObj_getFilterString(struct layerObj *self){
4771 1 : return msGetExpressionString(&(self->filter));
4772 : }
4773 : SWIGINTERN int layerObj_setWKTProjection(struct layerObj *self,char *wkt){
4774 0 : self->project = 1;
4775 0 : return msOGCWKT2ProjectionObj(wkt, &(self->projection), self->debug);
4776 : }
4777 : SWIGINTERN char *layerObj_getProjection(struct layerObj *self){
4778 0 : return (char *) msGetProjectionString(&(self->projection));
4779 : }
4780 : SWIGINTERN int layerObj_setProjection(struct layerObj *self,char *proj4){
4781 1 : self->project = 1;
4782 1 : return msLoadProjectionString(&(self->projection), proj4);
4783 : }
4784 1 : SWIGINTERN int layerObj_addFeature(struct layerObj *self,shapeObj *shape){
4785 1 : self->connectiontype = MS_INLINE;
4786 1 : if(self->features != NULL && self->features->tailifhead != NULL)
4787 1 : shape->index = self->features->tailifhead->shape.index + 1;
4788 : else
4789 1 : shape->index = 0;
4790 1 : if (insertFeatureList(&(self->features), shape) == NULL)
4791 : return MS_FAILURE;
4792 1 : return MS_SUCCESS;
4793 : }
4794 : SWIGINTERN int layerObj_getNumFeatures(struct layerObj *self){
4795 1 : return msLayerGetNumFeatures(self);
4796 : }
4797 : SWIGINTERN rectObj *layerObj_getExtent(struct layerObj *self){
4798 : rectObj *extent;
4799 1 : extent = (rectObj *) malloc(sizeof(rectObj));
4800 1 : msLayerGetExtent(self, extent);
4801 : return extent;
4802 : }
4803 1 : SWIGINTERN int layerObj_setExtent(struct layerObj *self,double minx,double miny,double maxx,double maxy){
4804 1 : if (minx > maxx || miny > maxy) {
4805 0 : msSetError(34,
4806 : "{ 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
4807 : "layerObj::setExtent()", minx, miny, maxx, maxy);
4808 0 : return MS_FAILURE;
4809 : }
4810 :
4811 1 : return msLayerSetExtent(self, minx, miny, maxx, maxy);
4812 : }
4813 0 : SWIGINTERN char *layerObj_getMetaData(struct layerObj *self,char *name){
4814 : char *value = NULL;
4815 0 : if (!name) {
4816 0 : msSetError(16, "NULL key", "getMetaData");
4817 : }
4818 :
4819 0 : value = (char *) msLookupHashTable(&(self->metadata), name);
4820 : /*
4821 : Umberto, 05/17/2006
4822 : Exceptions should be reserved for situations when a serious error occurred
4823 : and normal program flow must be interrupted.
4824 : In this case returning null should be more that enough.
4825 : */
4826 :
4827 0 : if (!value) {
4828 0 : msSetError(16, "Key %s does not exist", "getMetaData", name);
4829 0 : return NULL;
4830 : }
4831 :
4832 : return value;
4833 : }
4834 : SWIGINTERN int layerObj_setMetaData(struct layerObj *self,char *name,char *value){
4835 0 : if (msInsertHashTable(&(self->metadata), name, value) == NULL)
4836 : return MS_FAILURE;
4837 : return MS_SUCCESS;
4838 : }
4839 : SWIGINTERN int layerObj_removeMetaData(struct layerObj *self,char *name){
4840 0 : return(msRemoveHashTable(&(self->metadata), name));
4841 : }
4842 : SWIGINTERN char *layerObj_getFirstMetaDataKey(struct layerObj *self){
4843 1 : return (char *) msFirstKeyFromHashTable(&(self->metadata));
4844 : }
4845 : SWIGINTERN char *layerObj_getNextMetaDataKey(struct layerObj *self,char *lastkey){
4846 1 : return (char *) msNextKeyFromHashTable(&(self->metadata), lastkey);
4847 : }
4848 : SWIGINTERN char *layerObj_getWMSFeatureInfoURL(struct layerObj *self,mapObj *map,int click_x,int click_y,int feature_count,char *info_format){
4849 0 : return (char *) msWMSGetFeatureInfoURL(map, self, click_x, click_y,
4850 : feature_count, info_format);
4851 : }
4852 : SWIGINTERN char *layerObj_executeWFSGetFeature(struct layerObj *self,layerObj *layer){
4853 0 : return (char *) msWFSExecuteGetFeature(layer);
4854 : }
4855 : SWIGINTERN int layerObj_applySLD(struct layerObj *self,char *sld,char *stylelayer){
4856 0 : return msSLDApplySLD(self->map, sld, self->index, stylelayer, NULL);
4857 : }
4858 : SWIGINTERN int layerObj_applySLDURL(struct layerObj *self,char *sld,char *stylelayer){
4859 0 : return msSLDApplySLDURL(self->map, sld, self->index, stylelayer, NULL);
4860 : }
4861 : SWIGINTERN char *layerObj_generateSLD(struct layerObj *self){
4862 0 : return (char *) msSLDGenerateSLD(self->map, self->index, NULL);
4863 : }
4864 1 : SWIGINTERN int layerObj_isVisible(struct layerObj *self){
4865 1 : if (!self->map)
4866 : {
4867 0 : msSetError(12,
4868 : "visibility has no meaning outside of a map context",
4869 : "isVisible()");
4870 0 : return MS_FAILURE;
4871 : }
4872 1 : return msLayerIsVisible(self->map, self);
4873 : }
4874 : SWIGINTERN int layerObj_moveClassUp(struct layerObj *self,int index){
4875 0 : return msMoveClassUp(self, index);
4876 : }
4877 : SWIGINTERN int layerObj_moveClassDown(struct layerObj *self,int index){
4878 0 : return msMoveClassDown(self, index);
4879 : }
4880 : SWIGINTERN void layerObj_setProcessingKey(struct layerObj *self,char const *key,char const *value){
4881 0 : msLayerSetProcessingKey( self, key, value );
4882 : }
4883 : SWIGINTERN void layerObj_setProcessing(struct layerObj *self,char const *directive){
4884 1 : msLayerAddProcessing( self, directive );
4885 : }
4886 : SWIGINTERN void layerObj_addProcessing(struct layerObj *self,char const *directive){
4887 0 : msLayerAddProcessing( self, directive );
4888 : }
4889 : SWIGINTERN char *layerObj_getProcessing(struct layerObj *self,int index){
4890 1 : return (char *) msLayerGetProcessing(self, index);
4891 : }
4892 : SWIGINTERN char *layerObj_getProcessingKey(struct layerObj *self,char const *key){
4893 0 : return (char *) msLayerGetProcessingKey(self, key);
4894 : }
4895 : SWIGINTERN int layerObj_clearProcessing(struct layerObj *self){
4896 1 : return msLayerClearProcessing(self);
4897 : }
4898 0 : SWIGINTERN int layerObj_setConnectionType(struct layerObj *self,int connectiontype,char const *library_str){
4899 : /* Caller is responsible to close previous layer correctly before
4900 : * calling msConnectLayer()
4901 : */
4902 0 : if (msLayerIsOpen(self))
4903 0 : msLayerClose(self);
4904 0 : return msConnectLayer(self, connectiontype, library_str);
4905 : }
4906 : SWIGINTERN int layerObj_getClassIndex(struct layerObj *self,mapObj *map,shapeObj *shape,int *classgroup,int numclasses){
4907 0 : return msShapeGetClass(self, map, shape, classgroup, numclasses);
4908 : }
4909 : SWIGINTERN char *layerObj_getGeomTransform(struct layerObj *self){
4910 : return self->_geomtransform.string;
4911 : }
4912 0 : SWIGINTERN void layerObj_setGeomTransform(struct layerObj *self,char *transform){
4913 0 : msFree(self->_geomtransform.string);
4914 0 : if (!transform || strlen(transform) > 0) {
4915 0 : self->_geomtransform.string = msStrdup(transform);
4916 0 : self->_geomtransform.type = MS_GEOMTRANSFORM_EXPRESSION;
4917 : }
4918 : else {
4919 0 : self->_geomtransform.type = MS_GEOMTRANSFORM_NONE;
4920 0 : self->_geomtransform.string = NULL;
4921 : }
4922 0 : }
4923 1 : SWIGINTERN char *layerObj_getItemType(struct layerObj *self,int i){
4924 :
4925 : char *itemType = NULL;
4926 :
4927 1 : if (i >= 0 && i < self->numitems) {
4928 : gmlItemListObj *item_list;
4929 1 : item_list = msGMLGetItems(self, "G");
4930 1 : if (item_list != NULL) {
4931 1 : gmlItemObj *item = item_list->items + i;
4932 1 : itemType = msStrdup(item->type);
4933 1 : msGMLFreeItems(item_list); // destroy the original list
4934 : }
4935 : }
4936 :
4937 1 : return itemType;
4938 : }
4939 1 : SWIGINTERN struct mapObj *new_mapObj(char *filename){
4940 1 : if (filename && strlen(filename))
4941 1 : return msLoadMap(filename, NULL);
4942 : else { /* create an empty map, no layers etc... */
4943 1 : return msNewMapObj();
4944 : }
4945 : }
4946 : SWIGINTERN void delete_mapObj(struct mapObj *self){
4947 1 : msFreeMap(self);
4948 : }
4949 1 : SWIGINTERN mapObj *mapObj_clone(struct mapObj *self){
4950 : mapObj *dstMap;
4951 1 : dstMap = msNewMapObj();
4952 1 : if (msCopyMap(dstMap, self) != MS_SUCCESS) {
4953 0 : msFreeMap(dstMap);
4954 : dstMap = NULL;
4955 : }
4956 1 : return dstMap;
4957 : }
4958 : SWIGINTERN int mapObj_insertLayer(struct mapObj *self,layerObj *layer,int index){
4959 1 : return msInsertLayer(self, layer, index);
4960 : }
4961 : SWIGINTERN layerObj *mapObj_removeLayer(struct mapObj *self,int index){
4962 1 : layerObj *layer=msRemoveLayer(self, index);
4963 1 : MS_REFCNT_INCR(layer);
4964 : return layer;
4965 : }
4966 : SWIGINTERN int mapObj_setExtent(struct mapObj *self,double minx,double miny,double maxx,double maxy){
4967 1 : return msMapSetExtent( self, minx, miny, maxx, maxy );
4968 : }
4969 : SWIGINTERN int mapObj_offsetExtent(struct mapObj *self,double x,double y){
4970 0 : return msMapOffsetExtent( self, x, y );
4971 : }
4972 : SWIGINTERN int mapObj_scaleExtent(struct mapObj *self,double zoomfactor,double minscaledenom,double maxscaledenom){
4973 0 : return msMapScaleExtent( self, zoomfactor, minscaledenom, maxscaledenom );
4974 : }
4975 : SWIGINTERN int mapObj_setCenter(struct mapObj *self,pointObj *center){
4976 0 : return msMapSetCenter( self, center );
4977 : }
4978 : SWIGINTERN int mapObj_setSize(struct mapObj *self,int width,int height){
4979 1 : return msMapSetSize(self, width, height);
4980 : }
4981 : SWIGINTERN void mapObj_pixelToGeoref(struct mapObj *self,double pixPosX,double pixPosY,pointObj *geoPos){
4982 0 : geoPos->x = self->gt.geotransform[0] + self->gt.geotransform[1] * pixPosX + self->gt.geotransform[2] * pixPosY;
4983 0 : geoPos->y = self->gt.geotransform[3] + self->gt.geotransform[4] * pixPosX + self->gt.geotransform[5] * pixPosY;
4984 : }
4985 : SWIGINTERN double mapObj_getRotation(struct mapObj *self){
4986 : return self->gt.rotation_angle;
4987 : }
4988 : SWIGINTERN int mapObj_setRotation(struct mapObj *self,double rotation_angle){
4989 0 : return msMapSetRotation( self, rotation_angle );
4990 : }
4991 1 : SWIGINTERN layerObj *mapObj_getLayer(struct mapObj *self,int i){
4992 1 : if(i >= 0 && i < self->numlayers) {
4993 1 : MS_REFCNT_INCR(self->layers[i]);
4994 1 : return (self->layers[i]); /* returns an EXISTING layer */
4995 : } else {
4996 : return NULL;
4997 : }
4998 : }
4999 1 : SWIGINTERN layerObj *mapObj_getLayerByName(struct mapObj *self,char *name){
5000 : int i;
5001 :
5002 1 : i = msGetLayerIndex(self, name);
5003 :
5004 1 : if(i != -1) {
5005 1 : MS_REFCNT_INCR(self->layers[i]);
5006 1 : return (self->layers[i]); /* returns an EXISTING layer */
5007 : }
5008 : else
5009 : return NULL;
5010 : }
5011 : SWIGINTERN int mapObj_getSymbolByName(struct mapObj *self,char *name){
5012 0 : return msGetSymbolIndex(&self->symbolset, name, 1);
5013 : }
5014 0 : SWIGINTERN void mapObj_prepareQuery(struct mapObj *self){
5015 : int status;
5016 :
5017 0 : status = msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &self->scaledenom);
5018 0 : if(status != MS_SUCCESS) self->scaledenom = -1;
5019 0 : }
5020 : SWIGINTERN imageObj *mapObj_prepareImage(struct mapObj *self){
5021 1 : return msPrepareImage(self, 0);
5022 : }
5023 1 : SWIGINTERN void mapObj_setImageType(struct mapObj *self,char *imagetype){
5024 : outputFormatObj *format;
5025 :
5026 1 : format = msSelectOutputFormat( self, imagetype );
5027 1 : if( format == NULL )
5028 0 : msSetError(12, "Unable to find IMAGETYPE '%s'.",
5029 : "setImageType()", imagetype );
5030 : else
5031 : {
5032 1 : msFree( self->imagetype );
5033 1 : self->imagetype = msStrdup(imagetype);
5034 1 : msApplyOutputFormat( &(self->outputformat), format, -1111,
5035 : -1111, -1111 );
5036 : }
5037 1 : }
5038 1 : SWIGINTERN void mapObj_selectOutputFormat(struct mapObj *self,char *imagetype){
5039 : outputFormatObj *format;
5040 :
5041 1 : format = msSelectOutputFormat( self, imagetype );
5042 1 : if ( format == NULL )
5043 1 : msSetError(12, "Unable to find IMAGETYPE '%s'.",
5044 : "setImageType()", imagetype );
5045 : else
5046 : {
5047 1 : msFree( self->imagetype );
5048 1 : self->imagetype = msStrdup(imagetype);
5049 1 : msApplyOutputFormat( &(self->outputformat), format, -1111,
5050 : -1111, -1111 );
5051 : }
5052 1 : }
5053 0 : SWIGINTERN outputFormatObj *mapObj_getOutputFormat(struct mapObj *self,int i){
5054 0 : if(i >= 0 && i < self->numoutputformats) {
5055 0 : MS_REFCNT_INCR(self->outputformatlist[i]);
5056 0 : return (self->outputformatlist[i]);
5057 : } else {
5058 : return NULL;
5059 : }
5060 : }
5061 : SWIGINTERN void mapObj_setOutputFormat(struct mapObj *self,outputFormatObj *format){
5062 0 : msApplyOutputFormat( &(self->outputformat), format, -1111,
5063 : -1111, -1111 );
5064 : }
5065 : SWIGINTERN imageObj *mapObj_draw(struct mapObj *self){
5066 :
5067 :
5068 :
5069 :
5070 :
5071 :
5072 :
5073 :
5074 1 : return msDrawMap(self, 0);
5075 :
5076 : }
5077 : SWIGINTERN imageObj *mapObj_drawQuery(struct mapObj *self){
5078 0 : return msDrawMap(self, 1);
5079 : }
5080 : SWIGINTERN imageObj *mapObj_drawLegend(struct mapObj *self,int scale_independent){
5081 0 : return msDrawLegend(self, scale_independent, NULL);
5082 : }
5083 : SWIGINTERN imageObj *mapObj_drawScalebar(struct mapObj *self){
5084 0 : return msDrawScalebar(self);
5085 : }
5086 : SWIGINTERN imageObj *mapObj_drawReferenceMap(struct mapObj *self){
5087 0 : return msDrawReferenceMap(self);
5088 : }
5089 : SWIGINTERN int mapObj_embedScalebar(struct mapObj *self,imageObj *image){
5090 0 : return msEmbedScalebar(self, image);
5091 : }
5092 : SWIGINTERN int mapObj_embedLegend(struct mapObj *self,imageObj *image){
5093 0 : return msEmbedLegend(self, image);
5094 : }
5095 : SWIGINTERN int mapObj_drawLabelCache(struct mapObj *self,imageObj *image){
5096 0 : return msDrawLabelCache(self,image);
5097 : }
5098 0 : SWIGINTERN int mapObj_queryByFilter(struct mapObj *self,char *string){
5099 0 : msInitQuery(&(self->query));
5100 :
5101 0 : self->query.type = MS_QUERY_BY_FILTER;
5102 0 : self->query.mode = MS_QUERY_MULTIPLE;
5103 :
5104 0 : self->query.filter.string = msStrdup(string);
5105 0 : self->query.filter.type = MS_EXPRESSION;
5106 :
5107 0 : self->query.rect = self->extent;
5108 :
5109 0 : return msQueryByFilter(self);
5110 : }
5111 : SWIGINTERN int mapObj_queryByPoint(struct mapObj *self,pointObj *point,int mode,double buffer){
5112 1 : msInitQuery(&(self->query));
5113 :
5114 1 : self->query.type = MS_QUERY_BY_POINT;
5115 1 : self->query.mode = mode;
5116 1 : self->query.point = *point;
5117 1 : self->query.buffer = buffer;
5118 :
5119 1 : return msQueryByPoint(self);
5120 : }
5121 : SWIGINTERN int mapObj_queryByRect(struct mapObj *self,rectObj rect){
5122 0 : msInitQuery(&(self->query));
5123 :
5124 0 : self->query.type = MS_QUERY_BY_RECT;
5125 0 : self->query.mode = MS_QUERY_MULTIPLE;
5126 0 : self->query.rect = rect;
5127 :
5128 0 : return msQueryByRect(self);
5129 : }
5130 : SWIGINTERN int mapObj_queryByFeatures(struct mapObj *self,int slayer){
5131 0 : self->query.slayer = slayer;
5132 0 : return msQueryByFeatures(self);
5133 : }
5134 0 : SWIGINTERN int mapObj_queryByShape(struct mapObj *self,shapeObj *shape){
5135 0 : msInitQuery(&(self->query));
5136 :
5137 0 : self->query.type = MS_QUERY_BY_SHAPE;
5138 0 : self->query.mode = MS_QUERY_MULTIPLE;
5139 0 : self->query.shape = (shapeObj *) malloc(sizeof(shapeObj));
5140 0 : msInitShape(self->query.shape);
5141 0 : msCopyShape(shape, self->query.shape);
5142 :
5143 0 : return msQueryByShape(self);
5144 : }
5145 : SWIGINTERN int mapObj_setWKTProjection(struct mapObj *self,char *wkt){
5146 1 : return msOGCWKT2ProjectionObj(wkt, &(self->projection), self->debug);
5147 : }
5148 : SWIGINTERN char *mapObj_getProjection(struct mapObj *self){
5149 1 : return msGetProjectionString(&(self->projection));
5150 : }
5151 : SWIGINTERN int mapObj_setProjection(struct mapObj *self,char *proj4){
5152 1 : return msLoadProjectionString(&(self->projection), proj4);
5153 : }
5154 : SWIGINTERN int mapObj_save(struct mapObj *self,char *filename){
5155 1 : return msSaveMap(self, filename);
5156 : }
5157 : SWIGINTERN int mapObj_saveQuery(struct mapObj *self,char *filename,int results){
5158 1 : return msSaveQuery(self, filename, results);
5159 : }
5160 : SWIGINTERN int mapObj_loadQuery(struct mapObj *self,char *filename){
5161 1 : return msLoadQuery(self, filename);
5162 : }
5163 : SWIGINTERN void mapObj_freeQuery(struct mapObj *self,int qlayer){
5164 1 : msQueryFree(self, qlayer);
5165 : }
5166 : SWIGINTERN int mapObj_saveQueryAsGML(struct mapObj *self,char *filename,char const *ns){
5167 0 : return msGMLWriteQuery(self, filename, ns);
5168 : }
5169 1 : SWIGINTERN char *mapObj_getMetaData(struct mapObj *self,char *name){
5170 : char *value = NULL;
5171 1 : if (!name) {
5172 0 : msSetError(16, "NULL key", "getMetaData");
5173 : }
5174 :
5175 1 : value = (char *) msLookupHashTable(&(self->web.metadata), name);
5176 1 : if (!value) {
5177 1 : msSetError(16, "Key %s does not exist", "getMetaData", name);
5178 1 : return NULL;
5179 : }
5180 : return value;
5181 : }
5182 : SWIGINTERN int mapObj_setMetaData(struct mapObj *self,char *name,char *value){
5183 1 : if (msInsertHashTable(&(self->web.metadata), name, value) == NULL)
5184 : return MS_FAILURE;
5185 : return MS_SUCCESS;
5186 : }
5187 : SWIGINTERN int mapObj_removeMetaData(struct mapObj *self,char *name){
5188 0 : return(msRemoveHashTable(&(self->web.metadata), name));
5189 : }
5190 : SWIGINTERN char *mapObj_getFirstMetaDataKey(struct mapObj *self){
5191 1 : return (char *) msFirstKeyFromHashTable(&(self->web.metadata));
5192 : }
5193 : SWIGINTERN char *mapObj_getNextMetaDataKey(struct mapObj *self,char *lastkey){
5194 1 : return (char *) msNextKeyFromHashTable(&(self->web.metadata), lastkey);
5195 : }
5196 0 : SWIGINTERN int mapObj_setSymbolSet(struct mapObj *self,char *szFileName){
5197 0 : msFreeSymbolSet(&self->symbolset);
5198 0 : msInitSymbolSet(&self->symbolset);
5199 :
5200 0 : self->symbolset.filename = msStrdup(szFileName);
5201 :
5202 : /* Symbolset shares same fontset as main mapfile */
5203 0 : self->symbolset.fontset = &(self->fontset);
5204 :
5205 0 : return msLoadSymbolSet(&self->symbolset, self);
5206 : }
5207 : SWIGINTERN int mapObj_getNumSymbols(struct mapObj *self){
5208 : return self->symbolset.numsymbols;
5209 : }
5210 0 : SWIGINTERN int mapObj_setFontSet(struct mapObj *self,char *filename){
5211 0 : msFreeFontSet(&(self->fontset));
5212 0 : msInitFontSet(&(self->fontset));
5213 :
5214 0 : self->fontset.filename = msStrdup(filename);
5215 :
5216 0 : return msLoadFontSet(&(self->fontset), self);
5217 : }
5218 : SWIGINTERN int mapObj_saveMapContext(struct mapObj *self,char *szFileName){
5219 0 : return msSaveMapContext(self, szFileName);
5220 : }
5221 : SWIGINTERN int mapObj_loadMapContext(struct mapObj *self,char *szFileName,int useUniqueNames){
5222 0 : return msLoadMapContext(self, szFileName, useUniqueNames);
5223 : }
5224 : SWIGINTERN int mapObj_moveLayerUp(struct mapObj *self,int layerindex){
5225 0 : return msMoveLayerUp(self, layerindex);
5226 : }
5227 : SWIGINTERN int mapObj_moveLayerDown(struct mapObj *self,int layerindex){
5228 0 : return msMoveLayerDown(self, layerindex);
5229 : }
5230 0 : SWIGINTERN intarray *mapObj_getLayersDrawingOrder(struct mapObj *self){
5231 : int i;
5232 : intarray *order;
5233 0 : order = new_intarray(self->numlayers);
5234 0 : for (i=0; i<self->numlayers; i++)
5235 :
5236 0 : intarray___setitem__(order, i, self->layerorder[i]);
5237 :
5238 :
5239 :
5240 0 : return order;
5241 : }
5242 : SWIGINTERN int mapObj_setLayersDrawingOrder(struct mapObj *self,int *panIndexes){
5243 0 : return msSetLayersdrawingOrder(self, panIndexes);
5244 : }
5245 : SWIGINTERN void mapObj_setConfigOption(struct mapObj *self,char *key,char *value){
5246 0 : msSetConfigOption(self,key,value);
5247 : }
5248 : SWIGINTERN char *mapObj_getConfigOption(struct mapObj *self,char *key){
5249 0 : return (char *) msGetConfigOption(self,key);
5250 : }
5251 : SWIGINTERN void mapObj_applyConfigOptions(struct mapObj *self){
5252 0 : msApplyMapConfigOptions( self );
5253 : }
5254 : SWIGINTERN int mapObj_applySLD(struct mapObj *self,char *sld){
5255 0 : return msSLDApplySLD(self, sld, -1, NULL, NULL);
5256 : }
5257 : SWIGINTERN int mapObj_applySLDURL(struct mapObj *self,char *sld){
5258 0 : return msSLDApplySLDURL(self, sld, -1, NULL, NULL);
5259 : }
5260 : SWIGINTERN char *mapObj_generateSLD(struct mapObj *self,char *sldVersion){
5261 1 : return (char *) msSLDGenerateSLD(self, -1, sldVersion);
5262 : }
5263 : SWIGINTERN char *mapObj_processTemplate(struct mapObj *self,int bGenerateImages,char **names,char **values,int numentries){
5264 0 : return msProcessTemplate(self, bGenerateImages, names, values,
5265 : numentries);
5266 : }
5267 : SWIGINTERN char *mapObj_processLegendTemplate(struct mapObj *self,char **names,char **values,int numentries){
5268 0 : return msProcessLegendTemplate(self, names, values, numentries);
5269 : }
5270 : SWIGINTERN char *mapObj_processQueryTemplate(struct mapObj *self,char **names,char **values,int numentries){
5271 0 : return msProcessQueryTemplate(self, 1, names, values, numentries);
5272 : }
5273 : SWIGINTERN outputFormatObj *mapObj_getOutputFormatByName(struct mapObj *self,char *name){
5274 0 : return msSelectOutputFormat(self, name);
5275 : }
5276 : SWIGINTERN int mapObj_appendOutputFormat(struct mapObj *self,outputFormatObj *format){
5277 1 : return msAppendOutputFormat(self, format);
5278 : }
5279 : SWIGINTERN int mapObj_removeOutputFormat(struct mapObj *self,char *name){
5280 1 : return msRemoveOutputFormat(self, name);
5281 : }
5282 : SWIGINTERN int mapObj_loadOWSParameters(struct mapObj *self,cgiRequestObj *request,char *wmtver_string){
5283 1 : return msMapLoadOWSParameters(self, request, wmtver_string);
5284 : }
5285 : SWIGINTERN int mapObj_OWSDispatch(struct mapObj *self,cgiRequestObj *req){
5286 1 : return msOWSDispatch( self, req, 1 );
5287 : }
5288 : SWIGINTERN char *mapObj_convertToString(struct mapObj *self){
5289 0 : return msWriteMapToString(self);
5290 : }
5291 : SWIGINTERN void mapObj_applyDefaultSubstitutions(struct mapObj *self){
5292 1 : msApplyDefaultSubstitutions(self);
5293 : }
5294 : SWIGINTERN void mapObj_applySubstitutions(struct mapObj *self,char **names,char **values,int npairs){
5295 1 : msApplySubstitutions(self, names, values, npairs);
5296 : }
5297 1 : SWIGINTERN int mapObj_zoomPoint(struct mapObj *self,int zoomfactor,pointObj *poPixPos,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
5298 : double dfGeoPosX, dfGeoPosY;
5299 : double dfDeltaX, dfDeltaY;
5300 : rectObj oNewGeorefExt;
5301 : double dfNewScale;
5302 : int bMaxExtSet;
5303 : double dfDeltaExt;
5304 : double dX, dY;
5305 :
5306 1 : dfNewScale = 0.0;
5307 : bMaxExtSet = 0;
5308 : dfDeltaExt = -1.0;
5309 :
5310 1 : if (poMaxGeorefExt != NULL) { bMaxExtSet = 1; }
5311 :
5312 : /* ----------------------------------------------------------- */
5313 : /* check the validity of the parameters. */
5314 : /* ----------------------------------------------------------- */
5315 1 : if (zoomfactor == 0 || width <= 0 || height <= 0 || poGeorefExt == NULL || poPixPos == NULL) {
5316 1 : msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomPoint()");
5317 1 : return MS_FAILURE;
5318 : }
5319 :
5320 : /* ----------------------------------------------------------- */
5321 : /* check if the values passed are consistent min > max. */
5322 : /* ----------------------------------------------------------- */
5323 1 : if (poGeorefExt->minx >= poGeorefExt->maxx) {
5324 1 : msSetError(12, "Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomPoint()");
5325 1 : return MS_FAILURE;
5326 : }
5327 1 : if (poGeorefExt->miny >= poGeorefExt->maxy) {
5328 0 : msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomPoint()");
5329 0 : return MS_FAILURE;
5330 : }
5331 :
5332 1 : if (bMaxExtSet == 1) {
5333 1 : if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
5334 0 : msSetError(12, "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomPoint()");
5335 0 : return MS_FAILURE;
5336 : }
5337 1 : if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
5338 0 : msSetError(12, "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomPoint()");
5339 : }
5340 : }
5341 :
5342 1 : dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
5343 1 : dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
5344 1 : dX = dfDeltaX/((double)width);
5345 1 : dY = dfDeltaY/((double)height);
5346 1 : dfGeoPosX = poGeorefExt->minx + dX * (double)poPixPos->x;
5347 1 : dfGeoPosY = poGeorefExt->maxy - dY * (double)poPixPos->y;
5348 :
5349 1 : if (self->gt.rotation_angle != 0) {
5350 0 : dfGeoPosX = self->gt.geotransform[0] + self->gt.geotransform[1] * (double)poPixPos->x + self->gt.geotransform[2] * (double)poPixPos->y;
5351 0 : dfGeoPosY = self->gt.geotransform[3] + self->gt.geotransform[4] * (double)poPixPos->x + self->gt.geotransform[5] * (double)poPixPos->y;
5352 : }
5353 :
5354 : /* --- -------------------------------------------------------- */
5355 : /* zoom in */
5356 : /* ------------------------------------------------------------ */
5357 1 : if (zoomfactor > 1) {
5358 1 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/(2*zoomfactor));
5359 1 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/(2*zoomfactor));
5360 1 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/(2*zoomfactor));
5361 1 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/(2*zoomfactor));
5362 : }
5363 :
5364 1 : if (zoomfactor < 0) {
5365 1 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/2)*(abs(zoomfactor));
5366 1 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/2)*(abs(zoomfactor));
5367 1 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/2)*(abs(zoomfactor));
5368 1 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/2)*(abs(zoomfactor));
5369 : }
5370 :
5371 1 : if (zoomfactor == 1) {
5372 1 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaX/2);
5373 1 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaY/2);
5374 1 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaX/2);
5375 1 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaY/2);
5376 : }
5377 :
5378 : /* ------------------------------------------------------------ */
5379 : /* if the min and max scale are set in the map file, we will */
5380 : /* use them to test before zooming. */
5381 : /* ------------------------------------------------------------ */
5382 1 : msAdjustExtent(&oNewGeorefExt, self->width, self->height);
5383 1 : msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
5384 :
5385 1 : if (self->web.maxscaledenom > 0) {
5386 0 : if (zoomfactor < 0 && dfNewScale > self->web.maxscaledenom) {
5387 : return MS_FAILURE;
5388 : }
5389 : }
5390 :
5391 : /* ============================================================ */
5392 : /* we do a special case for zoom in : we try to zoom as much as */
5393 : /* possible using the mincale set in the .map. */
5394 : /* ============================================================ */
5395 1 : if (self->web.minscaledenom > 0 && dfNewScale < self->web.minscaledenom && zoomfactor > 1) {
5396 : /* To be consistent in swig mapscript and PHP mapscript,
5397 : use the same function to calculate the delta extents. */
5398 0 : dfDeltaExt = GetDeltaExtentsUsingScale(self->web.minscaledenom, self->units, dfGeoPosY,
5399 : self->width, self->resolution);
5400 :
5401 0 : if (dfDeltaExt > 0.0) {
5402 0 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
5403 0 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
5404 0 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
5405 0 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
5406 : } else
5407 : return MS_FAILURE;
5408 : }
5409 :
5410 : /* ------------------------------------------------------------ */
5411 : /* If the buffer is set, make sure that the extents do not go */
5412 : /* beyond the buffer. */
5413 : /* ------------------------------------------------------------ */
5414 1 : if (bMaxExtSet) {
5415 1 : dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
5416 1 : dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
5417 :
5418 : /* Make sure Current georef extents is not bigger than
5419 : * max extents */
5420 1 : if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
5421 : dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
5422 1 : if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
5423 : dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
5424 :
5425 1 : if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
5426 1 : oNewGeorefExt.minx = poMaxGeorefExt->minx;
5427 1 : oNewGeorefExt.maxx = oNewGeorefExt.minx + dfDeltaX;
5428 : }
5429 1 : if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
5430 0 : oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
5431 0 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5432 : }
5433 1 : if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
5434 1 : oNewGeorefExt.miny = poMaxGeorefExt->miny;
5435 1 : oNewGeorefExt.maxy = oNewGeorefExt.miny + dfDeltaY;
5436 : }
5437 1 : if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
5438 0 : oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
5439 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5440 : }
5441 : }
5442 :
5443 : /* ------------------------------------------------------------ */
5444 : /* set the map extents with new values. */
5445 : /* ------------------------------------------------------------ */
5446 1 : self->extent.minx = oNewGeorefExt.minx;
5447 1 : self->extent.miny = oNewGeorefExt.miny;
5448 1 : self->extent.maxx = oNewGeorefExt.maxx;
5449 1 : self->extent.maxy = oNewGeorefExt.maxy;
5450 :
5451 1 : self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);
5452 1 : dfDeltaX = self->extent.maxx - self->extent.minx;
5453 1 : dfDeltaY = self->extent.maxy - self->extent.miny;
5454 :
5455 1 : if (bMaxExtSet) {
5456 1 : if (self->extent.minx < poMaxGeorefExt->minx) {
5457 0 : self->extent.minx = poMaxGeorefExt->minx;
5458 0 : self->extent.maxx = self->extent.minx + dfDeltaX;
5459 : }
5460 1 : if (self->extent.maxx > poMaxGeorefExt->maxx) {
5461 0 : self->extent.maxx = poMaxGeorefExt->maxx;
5462 0 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5463 : }
5464 1 : if (self->extent.miny < poMaxGeorefExt->miny) {
5465 0 : self->extent.miny = poMaxGeorefExt->miny;
5466 0 : self->extent.maxy = self->extent.miny + dfDeltaY;
5467 : }
5468 1 : if (self->extent.maxy > poMaxGeorefExt->maxy) {
5469 0 : self->extent.maxy = poMaxGeorefExt->maxy;
5470 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5471 : }
5472 : }
5473 :
5474 1 : msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &(self->scaledenom));
5475 :
5476 1 : return MS_SUCCESS;
5477 : }
5478 1 : SWIGINTERN int mapObj_zoomRectangle(struct mapObj *self,rectObj *poPixRect,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
5479 : double dfDeltaX, dfDeltaY;
5480 : rectObj oNewGeorefExt;
5481 : double dfNewScale;
5482 : double dfDeltaExt;
5483 : double dfMiddleX, dfMiddleY;
5484 : int bMaxExtSet;
5485 :
5486 : bMaxExtSet = 0;
5487 1 : dfNewScale = 0.0;
5488 : dfDeltaExt = -1.0;
5489 :
5490 1 : if (poMaxGeorefExt != NULL) bMaxExtSet = 1;
5491 :
5492 : /* ----------------------------------------------------------- */
5493 : /* check the validity of the parameters. */
5494 : /* ----------------------------------------------------------- */
5495 1 : if (poPixRect == 0 || width <= 0 || height <= 0 || poGeorefExt == NULL) {
5496 0 : msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomRectangle");
5497 0 : return MS_FAILURE;
5498 : }
5499 :
5500 : /* ----------------------------------------------------------- */
5501 : /* check if the values passed are consistent min <= max. */
5502 : /* ----------------------------------------------------------- */
5503 1 : if (poPixRect->minx >= poPixRect->maxx) {
5504 0 : msSetError(12, "image rectangle minx >= maxx", "mapscript::mapObj::zoomRectangle()");
5505 0 : return MS_FAILURE;
5506 : }
5507 : /* This is not a typo: "maxx >= minx". For historical reason, we
5508 : * keep this as it is. See documentation for more info about this check. */
5509 1 : if (poPixRect->maxy >= poPixRect->miny) {
5510 1 : msSetError(12, "image rectangle maxy >= miny", "mapscript::mapObj::zoomRectangle()");
5511 1 : return MS_FAILURE;
5512 : }
5513 :
5514 1 : if (poGeorefExt->minx >= poGeorefExt->maxx) {
5515 0 : msSetError(12, "Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomRectangle()");
5516 0 : return MS_FAILURE;
5517 : }
5518 1 : if (poGeorefExt->miny >= poGeorefExt->maxy) {
5519 0 : msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomRectangle()");
5520 0 : return MS_FAILURE;
5521 : }
5522 :
5523 1 : if (bMaxExtSet == 1) {
5524 1 : if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
5525 0 : msSetError(12, "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomRectangle()");
5526 0 : return MS_FAILURE;
5527 : }
5528 1 : if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
5529 0 : msSetError(12, "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomRectangle()");
5530 0 : return MS_FAILURE;
5531 : }
5532 : }
5533 :
5534 :
5535 : /* ----------------------------------------------------------- */
5536 : /* Convert pixel rectangle to georeferenced rectangle */
5537 : /* ----------------------------------------------------------- */
5538 :
5539 : dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
5540 : dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
5541 :
5542 1 : oNewGeorefExt.minx = Pix2Georef((int)poPixRect->minx, 0, width, poGeorefExt->minx, poGeorefExt->maxx, 0);
5543 1 : oNewGeorefExt.maxx = Pix2Georef((int)poPixRect->maxx, 0, width, poGeorefExt->minx, poGeorefExt->maxx, 0);
5544 1 : oNewGeorefExt.miny = Pix2Georef((int)poPixRect->miny, 0, height, poGeorefExt->miny, poGeorefExt->maxy, 1);
5545 1 : oNewGeorefExt.maxy = Pix2Georef((int)poPixRect->maxy, 0, height, poGeorefExt->miny, poGeorefExt->maxy, 1);
5546 :
5547 1 : msAdjustExtent(&oNewGeorefExt, self->width, self->height);
5548 :
5549 : /* ------------------------------------------------------------ */
5550 : /* if the min and max scale are set in the map file, we will */
5551 : /* use them to test before setting extents. */
5552 : /* ------------------------------------------------------------ */
5553 1 : msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
5554 :
5555 1 : if (self->web.maxscaledenom > 0 && dfNewScale > self->web.maxscaledenom)
5556 : return MS_FAILURE;
5557 :
5558 1 : if (self->web.minscaledenom > 0 && dfNewScale < self->web.minscaledenom) {
5559 0 : dfMiddleX = oNewGeorefExt.minx + ((oNewGeorefExt.maxx - oNewGeorefExt.minx)/2);
5560 0 : dfMiddleY = oNewGeorefExt.miny + ((oNewGeorefExt.maxy - oNewGeorefExt.miny)/2);
5561 :
5562 : /* To be consistent in swig mapscript and PHP mapscript,
5563 : use the same function to calculate the delta extents. */
5564 0 : dfDeltaExt = GetDeltaExtentsUsingScale(self->web.minscaledenom, self->units, dfMiddleY, self->width, self->resolution);
5565 :
5566 0 : if (dfDeltaExt > 0.0) {
5567 0 : oNewGeorefExt.minx = dfMiddleX - (dfDeltaExt/2);
5568 0 : oNewGeorefExt.miny = dfMiddleY - (dfDeltaExt/2);
5569 0 : oNewGeorefExt.maxx = dfMiddleX + (dfDeltaExt/2);
5570 0 : oNewGeorefExt.maxy = dfMiddleY + (dfDeltaExt/2);
5571 : } else
5572 : return MS_FAILURE;
5573 : }
5574 :
5575 : /* ------------------------------------------------------------ */
5576 : /* If the buffer is set, make sure that the extents do not go */
5577 : /* beyond the buffer. */
5578 : /* ------------------------------------------------------------ */
5579 1 : if (bMaxExtSet) {
5580 1 : dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
5581 1 : dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
5582 :
5583 : /* Make sure Current georef extents is not bigger
5584 : * than max extents */
5585 1 : if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
5586 : dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
5587 1 : if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
5588 : dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
5589 :
5590 1 : if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
5591 0 : oNewGeorefExt.minx = poMaxGeorefExt->minx;
5592 0 : oNewGeorefExt.maxx = oNewGeorefExt.minx + dfDeltaX;
5593 : }
5594 1 : if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
5595 1 : oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
5596 1 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5597 : }
5598 1 : if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
5599 1 : oNewGeorefExt.miny = poMaxGeorefExt->miny;
5600 1 : oNewGeorefExt.maxy = oNewGeorefExt.miny + dfDeltaY;
5601 : }
5602 1 : if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
5603 0 : oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
5604 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5605 : }
5606 : }
5607 :
5608 1 : self->extent.minx = oNewGeorefExt.minx;
5609 1 : self->extent.miny = oNewGeorefExt.miny;
5610 1 : self->extent.maxx = oNewGeorefExt.maxx;
5611 1 : self->extent.maxy = oNewGeorefExt.maxy;
5612 :
5613 1 : self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);
5614 1 : dfDeltaX = self->extent.maxx - self->extent.minx;
5615 1 : dfDeltaY = self->extent.maxy - self->extent.miny;
5616 :
5617 1 : if (bMaxExtSet) {
5618 1 : if (self->extent.minx < poMaxGeorefExt->minx) {
5619 0 : self->extent.minx = poMaxGeorefExt->minx;
5620 0 : self->extent.maxx = self->extent.minx + dfDeltaX;
5621 : }
5622 1 : if (self->extent.maxx > poMaxGeorefExt->maxx) {
5623 0 : self->extent.maxx = poMaxGeorefExt->maxx;
5624 0 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5625 : }
5626 1 : if (self->extent.miny < poMaxGeorefExt->miny) {
5627 0 : self->extent.miny = poMaxGeorefExt->miny;
5628 0 : self->extent.maxy = self->extent.miny + dfDeltaY;
5629 : }
5630 1 : if (self->extent.maxy > poMaxGeorefExt->maxy) {
5631 0 : self->extent.maxy = poMaxGeorefExt->maxy;
5632 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5633 : }
5634 : }
5635 :
5636 1 : msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &(self->scaledenom));
5637 :
5638 1 : return MS_SUCCESS;
5639 : }
5640 1 : SWIGINTERN int mapObj_zoomScale(struct mapObj *self,double scale,pointObj *poPixPos,int width,int height,rectObj *poGeorefExt,rectObj *poMaxGeorefExt){
5641 : double dfGeoPosX, dfGeoPosY;
5642 : double dfDeltaX, dfDeltaY;
5643 : rectObj oNewGeorefExt;
5644 : double dfNewScale, dfCurrentScale;
5645 : int bMaxExtSet;
5646 : int nTmp;
5647 : double dfDeltaExt;
5648 : double dX, dY;
5649 :
5650 1 : dfNewScale = 0.0;
5651 1 : dfCurrentScale = 0.0;
5652 : nTmp = 0;
5653 : bMaxExtSet = 0;
5654 : dfDeltaExt = -1.0;
5655 :
5656 1 : if (poMaxGeorefExt != NULL) { bMaxExtSet = 1; }
5657 :
5658 : /* ----------------------------------------------------------- */
5659 : /* check the validity of the parameters. */
5660 : /* ----------------------------------------------------------- */
5661 1 : if (scale <= 0.0 || width <= 0 || height <= 0 || poGeorefExt == NULL || poPixPos == NULL ) {
5662 0 : msSetError(12, "Incorrect arguments", "mapscript::mapObj::zoomScale");
5663 0 : return MS_FAILURE;
5664 : }
5665 :
5666 : /* ----------------------------------------------------------- */
5667 : /* check if the values passed are consistent min > max. */
5668 : /* ----------------------------------------------------------- */
5669 1 : if (poGeorefExt->minx >= poGeorefExt->maxx) {
5670 0 : msSetError(12, "Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomScale()");
5671 0 : return MS_FAILURE;
5672 : }
5673 1 : if (poGeorefExt->miny >= poGeorefExt->maxy) {
5674 0 : msSetError(12, "Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomScale()");
5675 0 : return MS_FAILURE;
5676 : }
5677 :
5678 1 : if (bMaxExtSet == 1) {
5679 1 : if (poMaxGeorefExt->minx >= poMaxGeorefExt->maxx) {
5680 0 : msSetError(12, "Max Georeferenced coordinates minx >= maxx", "mapscript::mapObj::zoomScale()");
5681 0 : return MS_FAILURE;
5682 : }
5683 1 : if (poMaxGeorefExt->miny >= poMaxGeorefExt->maxy) {
5684 0 : msSetError(12, "Max Georeferenced coordinates miny >= maxy", "mapscript::mapObj::zoomScale()");
5685 : }
5686 : }
5687 :
5688 1 : dfDeltaX = poGeorefExt->maxx - poGeorefExt->minx;
5689 1 : dfDeltaY = poGeorefExt->maxy - poGeorefExt->miny;
5690 1 : dX = dfDeltaX/((double)width);
5691 1 : dY = dfDeltaY/((double)height);
5692 1 : dfGeoPosX = poGeorefExt->minx + dX * (double)poPixPos->x;
5693 1 : dfGeoPosY = poGeorefExt->maxy - dY * (double)poPixPos->y;
5694 :
5695 1 : if (self->gt.rotation_angle != 0) {
5696 0 : dfGeoPosX = self->gt.geotransform[0] + self->gt.geotransform[1] * (double)poPixPos->x + self->gt.geotransform[2] * (double)poPixPos->y;
5697 0 : dfGeoPosY = self->gt.geotransform[3] + self->gt.geotransform[4] * (double)poPixPos->x + self->gt.geotransform[5] * (double)poPixPos->y;
5698 : }
5699 :
5700 : /* ------------------------------------------------------------ */
5701 : /* Calculate new extents based on the scale. */
5702 : /* ------------------------------------------------------------ */
5703 :
5704 : /* ============================================================ */
5705 : /* make sure to take the smallest size because this is the one */
5706 : /* that will be used to ajust the scale. */
5707 : /* ============================================================ */
5708 :
5709 1 : if (self->width < self->height)
5710 : nTmp = self->width;
5711 : else
5712 : nTmp = self->height;
5713 :
5714 : /* To be consistent in swig mapscript and PHP mapscript,
5715 : use the same function to calculate the delta extents. */
5716 1 : dfDeltaExt = GetDeltaExtentsUsingScale(scale, self->units, dfGeoPosY, nTmp, self->resolution);
5717 :
5718 1 : if (dfDeltaExt > 0.0) {
5719 1 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
5720 1 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
5721 1 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
5722 1 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
5723 : } else
5724 : return MS_FAILURE;
5725 :
5726 : /* ------------------------------------------------------------ */
5727 : /* get current scale. */
5728 : /* ------------------------------------------------------------ */
5729 1 : msCalculateScale(*poGeorefExt, self->units, self->width, self->height, self->resolution, &dfCurrentScale);
5730 :
5731 : /* ------------------------------------------------------------ *
5732 : * if the min and max scale are set in the map file, we will *
5733 : * use them to test before zooming. *
5734 : * *
5735 : * This function has the same effect as zoomin or zoom out.
5736 : * If the current scale is > newscale we zoom in; else it is
5737 : * a zoom out.
5738 : * ------------------------------------------------------------ */
5739 1 : msAdjustExtent(&oNewGeorefExt, self->width, self->height);
5740 1 : msCalculateScale(oNewGeorefExt, self->units, self->width, self->height, self->resolution, &dfNewScale);
5741 :
5742 1 : if (self->web.maxscaledenom > 0) {
5743 0 : if (dfCurrentScale < dfNewScale && dfNewScale > self->web.maxscaledenom) {
5744 : return MS_FAILURE;
5745 : }
5746 : }
5747 :
5748 : /* ============================================================ */
5749 : /* we do a special case for zoom in : we try to zoom as much as */
5750 : /* possible using the mincale set in the .map. */
5751 : /* ============================================================ */
5752 1 : if (self->web.minscaledenom > 0 && dfNewScale < self->web.minscaledenom && dfCurrentScale > dfNewScale) {
5753 : /* To be consistent in swig mapscript and PHP mapscript,
5754 : use the same function to calculate the delta extents. */
5755 0 : dfDeltaExt = GetDeltaExtentsUsingScale(scale, self->units, dfGeoPosY, nTmp, self->resolution);
5756 0 : if (dfDeltaExt > 0.0) {
5757 0 : oNewGeorefExt.minx = dfGeoPosX - (dfDeltaExt/2);
5758 0 : oNewGeorefExt.miny = dfGeoPosY - (dfDeltaExt/2);
5759 0 : oNewGeorefExt.maxx = dfGeoPosX + (dfDeltaExt/2);
5760 0 : oNewGeorefExt.maxy = dfGeoPosY + (dfDeltaExt/2);
5761 : } else
5762 : return MS_FAILURE;
5763 : }
5764 :
5765 : /* ------------------------------------------------------------ */
5766 : /* If the buffer is set, make sure that the extents do not go */
5767 : /* beyond the buffer. */
5768 : /* ------------------------------------------------------------ */
5769 1 : if (bMaxExtSet) {
5770 1 : dfDeltaX = oNewGeorefExt.maxx - oNewGeorefExt.minx;
5771 1 : dfDeltaY = oNewGeorefExt.maxy - oNewGeorefExt.miny;
5772 :
5773 : /* Make sure Current georef extents is not bigger
5774 : * than max extents */
5775 1 : if (dfDeltaX > (poMaxGeorefExt->maxx-poMaxGeorefExt->minx))
5776 : dfDeltaX = poMaxGeorefExt->maxx-poMaxGeorefExt->minx;
5777 1 : if (dfDeltaY > (poMaxGeorefExt->maxy-poMaxGeorefExt->miny))
5778 : dfDeltaY = poMaxGeorefExt->maxy-poMaxGeorefExt->miny;
5779 :
5780 1 : if (oNewGeorefExt.minx < poMaxGeorefExt->minx) {
5781 1 : oNewGeorefExt.minx = poMaxGeorefExt->minx;
5782 1 : oNewGeorefExt.maxx = oNewGeorefExt.minx + dfDeltaX;
5783 : }
5784 1 : if (oNewGeorefExt.maxx > poMaxGeorefExt->maxx) {
5785 0 : oNewGeorefExt.maxx = poMaxGeorefExt->maxx;
5786 0 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5787 : }
5788 1 : if (oNewGeorefExt.miny < poMaxGeorefExt->miny) {
5789 1 : oNewGeorefExt.miny = poMaxGeorefExt->miny;
5790 1 : oNewGeorefExt.maxy = oNewGeorefExt.miny + dfDeltaY;
5791 : }
5792 1 : if (oNewGeorefExt.maxy > poMaxGeorefExt->maxy) {
5793 0 : oNewGeorefExt.maxy = poMaxGeorefExt->maxy;
5794 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5795 : }
5796 : }
5797 :
5798 1 : self->extent.minx = oNewGeorefExt.minx;
5799 1 : self->extent.miny = oNewGeorefExt.miny;
5800 1 : self->extent.maxx = oNewGeorefExt.maxx;
5801 1 : self->extent.maxy = oNewGeorefExt.maxy;
5802 :
5803 1 : self->cellsize = msAdjustExtent(&(self->extent), self->width, self->height);
5804 1 : dfDeltaX = self->extent.maxx - self->extent.minx;
5805 1 : dfDeltaY = self->extent.maxy - self->extent.miny;
5806 :
5807 1 : if (bMaxExtSet) {
5808 1 : if (self->extent.minx < poMaxGeorefExt->minx) {
5809 0 : self->extent.minx = poMaxGeorefExt->minx;
5810 0 : self->extent.maxx = self->extent.minx + dfDeltaX;
5811 : }
5812 1 : if (self->extent.maxx > poMaxGeorefExt->maxx) {
5813 0 : self->extent.maxx = poMaxGeorefExt->maxx;
5814 0 : oNewGeorefExt.minx = oNewGeorefExt.maxx - dfDeltaX;
5815 : }
5816 1 : if (self->extent.miny < poMaxGeorefExt->miny) {
5817 0 : self->extent.miny = poMaxGeorefExt->miny;
5818 0 : self->extent.maxy = self->extent.miny + dfDeltaY;
5819 : }
5820 1 : if (self->extent.maxy > poMaxGeorefExt->maxy) {
5821 0 : self->extent.maxy = poMaxGeorefExt->maxy;
5822 0 : oNewGeorefExt.miny = oNewGeorefExt.maxy - dfDeltaY;
5823 : }
5824 : }
5825 :
5826 1 : msCalculateScale(self->extent, self->units, self->width, self->height, self->resolution, &(self->scaledenom));
5827 :
5828 1 : return MS_SUCCESS;
5829 : }
5830 1 : SWIGINTERN PyObject *mapObj_getLayerOrder(struct mapObj *self){
5831 : int i;
5832 : PyObject *order;
5833 1 : order = PyTuple_New(self->numlayers);
5834 1 : for (i = 0; i < self->numlayers; i++) {
5835 1 : PyTuple_SetItem(order,i,PyInt_FromLong((long)self->layerorder[i]));
5836 : }
5837 1 : return order;
5838 : }
5839 1 : SWIGINTERN int mapObj_setLayerOrder(struct mapObj *self,PyObject *order){
5840 : int i;
5841 1 : Py_ssize_t size = PyTuple_Size(order);
5842 1 : for (i = 0; i < size; i++) {
5843 1 : self->layerorder[i] = (int)PyInt_AsLong(PyTuple_GetItem(order, i));
5844 : }
5845 1 : return MS_SUCCESS;
5846 : }
5847 1 : SWIGINTERN PyObject *mapObj_getSize(struct mapObj *self){
5848 : PyObject* output ;
5849 1 : output = PyTuple_New(2);
5850 1 : PyTuple_SetItem(output,0,PyInt_FromLong((long)self->width));
5851 1 : PyTuple_SetItem(output,1,PyInt_FromLong((long)self->height));
5852 1 : return output;
5853 : }
5854 1 : SWIGINTERN rectObj *new_rectObj(double minx,double miny,double maxx,double maxy,int imageunits){
5855 : rectObj *rect;
5856 :
5857 1 : if (imageunits == 0)
5858 : {
5859 1 : if (minx > maxx || miny > maxy)
5860 : {
5861 1 : msSetError(34,
5862 : "{ 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
5863 : "rectObj()", minx, miny, maxx, maxy);
5864 1 : return NULL;
5865 : }
5866 : }
5867 : else
5868 : {
5869 1 : if (minx > maxx || maxy > miny)
5870 : {
5871 1 : msSetError(34,
5872 : "image (pixel/line) units { 'minx': %f , 'miny': %f , 'maxx': %f , 'maxy': %f }",
5873 : "rectObj()", minx, miny, maxx, maxy);
5874 1 : return NULL;
5875 : }
5876 : }
5877 :
5878 1 : rect = (rectObj *)calloc(1, sizeof(rectObj));
5879 1 : if (!rect)
5880 : return(NULL);
5881 :
5882 1 : rect->minx = minx;
5883 1 : rect->miny = miny;
5884 1 : rect->maxx = maxx;
5885 1 : rect->maxy = maxy;
5886 :
5887 1 : return(rect);
5888 : }
5889 : SWIGINTERN void delete_rectObj(rectObj *self){
5890 1 : free(self);
5891 : }
5892 : SWIGINTERN int rectObj_project(rectObj *self,projectionObj *projin,projectionObj *projout){
5893 0 : return msProjectRect(projin, projout, self);
5894 : }
5895 : SWIGINTERN double rectObj_fit(rectObj *self,int width,int height){
5896 0 : return msAdjustExtent(self, width, height);
5897 : }
5898 0 : SWIGINTERN int rectObj_draw(rectObj *self,mapObj *map,layerObj *layer,imageObj *image,int classindex,char *text){
5899 : shapeObj shape;
5900 : int ret;
5901 :
5902 0 : msInitShape(&shape);
5903 0 : msRectToPolygon(*self, &shape);
5904 0 : shape.classindex = classindex;
5905 0 : if(text && layer->class[classindex]->numlabels > 0) {
5906 0 : shape.text = msStrdup(text);
5907 : }
5908 :
5909 0 : ret = msDrawShape(map, layer, &shape, image, -1, MS_DRAWMODE_FEATURES|MS_DRAWMODE_LABELS);
5910 :
5911 0 : msFreeShape(&shape);
5912 :
5913 0 : return ret;
5914 : }
5915 0 : SWIGINTERN pointObj *rectObj_getCenter(rectObj *self){
5916 : pointObj *center;
5917 0 : center = (pointObj *)calloc(1, sizeof(pointObj));
5918 0 : if (!center) {
5919 0 : msSetError(2, "Failed to allocate memory for point", "getCenter()");
5920 0 : return NULL;
5921 : }
5922 0 : center->x = (self->minx + self->maxx)/2;
5923 0 : center->y = (self->miny + self->maxy)/2;
5924 :
5925 0 : return center;
5926 : }
5927 1 : SWIGINTERN shapeObj *rectObj_toPolygon(rectObj *self){
5928 1 : lineObj line = {0,NULL};
5929 : shapeObj *shape;
5930 1 : shape = (shapeObj *)malloc(sizeof(shapeObj));
5931 1 : if (!shape)
5932 : return NULL;
5933 1 : msInitShape(shape);
5934 1 : shape->type = MS_SHAPE_POLYGON;
5935 :
5936 1 : line.point = (pointObj *)malloc(sizeof(pointObj)*5);
5937 1 : line.point[0].x = self->minx;
5938 1 : line.point[0].y = self->miny;
5939 1 : line.point[1].x = self->minx;
5940 1 : line.point[1].y = self->maxy;
5941 1 : line.point[2].x = self->maxx;
5942 1 : line.point[2].y = self->maxy;
5943 1 : line.point[3].x = self->maxx;
5944 1 : line.point[3].y = self->miny;
5945 1 : line.point[4].x = line.point[0].x;
5946 1 : line.point[4].y = line.point[0].y;
5947 :
5948 1 : line.numpoints = 5;
5949 :
5950 1 : msAddLine(shape, &line);
5951 1 : msComputeBounds(shape);
5952 :
5953 1 : free(line.point);
5954 :
5955 1 : return shape;
5956 : }
5957 1 : SWIGINTERN char *rectObj_toString(rectObj *self){
5958 : char buffer[256];
5959 1 : char fmt[]="{ 'minx': %.16g , 'miny': %.16g , 'maxx': %.16g , 'maxy': %.16g }";
5960 1 : msRectToFormattedString(self, (char *) &fmt, (char *) &buffer, 256);
5961 1 : return msStrdup(buffer);
5962 : }
5963 : SWIGINTERN pointObj *new_pointObj(double x,double y,double z,double m){
5964 : pointObj *p;
5965 1 : p = (pointObj *)calloc(1,sizeof(pointObj));
5966 1 : if (!p) return NULL;
5967 1 : p->x = x;
5968 1 : p->y = y;
5969 :
5970 :
5971 :
5972 :
5973 : return p;
5974 : }
5975 : SWIGINTERN void delete_pointObj(pointObj *self){
5976 1 : free(self);
5977 : }
5978 : SWIGINTERN int pointObj_project(pointObj *self,projectionObj *projin,projectionObj *projout){
5979 1 : return msProjectPoint(projin, projout, self);
5980 : }
5981 : SWIGINTERN int pointObj_draw(pointObj *self,mapObj *map,layerObj *layer,imageObj *image,int classindex,char *text){
5982 1 : return msDrawPoint(map, layer, self, image, classindex, text);
5983 : }
5984 : SWIGINTERN double pointObj_distanceToPoint(pointObj *self,pointObj *point){
5985 0 : return msDistancePointToPoint(self, point);
5986 : }
5987 : SWIGINTERN double pointObj_distanceToSegment(pointObj *self,pointObj *a,pointObj *b){
5988 0 : return msDistancePointToSegment(self, a, b);
5989 : }
5990 : SWIGINTERN double pointObj_distanceToShape(pointObj *self,shapeObj *shape){
5991 0 : return msDistancePointToShape(self, shape);
5992 : }
5993 : SWIGINTERN int pointObj_setXY(pointObj *self,double x,double y,double m){
5994 1 : self->x = x;
5995 1 : self->y = y;
5996 :
5997 :
5998 :
5999 :
6000 : return MS_SUCCESS;
6001 : }
6002 : SWIGINTERN int pointObj_setXYZ(pointObj *self,double x,double y,double z,double m){
6003 1 : self->x = x;
6004 1 : self->y = y;
6005 :
6006 :
6007 :
6008 :
6009 : return MS_SUCCESS;
6010 : }
6011 : SWIGINTERN int pointObj_setXYZM(pointObj *self,double x,double y,double z,double m){
6012 0 : self->x = x;
6013 0 : self->y = y;
6014 :
6015 :
6016 :
6017 :
6018 : return MS_SUCCESS;
6019 : }
6020 1 : SWIGINTERN char *pointObj_toString(pointObj *self){
6021 : char buffer[256];
6022 : const char *fmt;
6023 :
6024 :
6025 :
6026 :
6027 :
6028 :
6029 :
6030 : fmt = "{ 'x': %.16g, 'y': %.16g }";
6031 :
6032 :
6033 1 : msPointToFormattedString(self, fmt, (char *) &buffer, 256);
6034 1 : return msStrdup(buffer);
6035 : }
6036 0 : SWIGINTERN shapeObj *pointObj_toShape(pointObj *self){
6037 : shapeObj *shape;
6038 :
6039 0 : shape = (shapeObj *) malloc(sizeof(shapeObj));
6040 0 : msInitShape(shape);
6041 :
6042 0 : shape->type = MS_SHAPE_POINT;
6043 0 : shape->line = (lineObj *) malloc(sizeof(lineObj));
6044 0 : shape->numlines = 1;
6045 0 : shape->line[0].point = (pointObj *) malloc(sizeof(pointObj));
6046 0 : shape->line[0].numpoints = 1;
6047 :
6048 0 : shape->line[0].point[0].x = self->x;
6049 0 : shape->line[0].point[0].y = self->y;
6050 :
6051 :
6052 :
6053 :
6054 :
6055 0 : return shape;
6056 : }
6057 : SWIGINTERN lineObj *new_lineObj(void){
6058 : lineObj *line;
6059 :
6060 1 : line = (lineObj *)malloc(sizeof(lineObj));
6061 1 : if (!line)
6062 : return(NULL);
6063 :
6064 1 : line->numpoints=0;
6065 1 : line->point=NULL;
6066 :
6067 : return line;
6068 : }
6069 : SWIGINTERN void delete_lineObj(lineObj *self){
6070 1 : free(self->point);
6071 1 : free(self);
6072 : }
6073 : SWIGINTERN int lineObj_project(lineObj *self,projectionObj *projin,projectionObj *projout){
6074 0 : return msProjectLine(projin, projout, self);
6075 : }
6076 : SWIGINTERN pointObj *lineObj_get(lineObj *self,int i){
6077 1 : if (i<0 || i>=self->numpoints)
6078 : return NULL;
6079 : else
6080 1 : return &(self->point[i]);
6081 : }
6082 1 : SWIGINTERN int lineObj_add(lineObj *self,pointObj *p){
6083 1 : if (self->numpoints == 0) { /* new */
6084 1 : self->point = (pointObj *)malloc(sizeof(pointObj));
6085 1 : if (!self->point)
6086 : return MS_FAILURE;
6087 : } else { /* extend array */
6088 1 : self->point = (pointObj *)realloc(self->point,
6089 1 : sizeof(pointObj)*(self->numpoints+1));
6090 1 : if (!self->point)
6091 : return MS_FAILURE;
6092 : }
6093 :
6094 1 : self->point[self->numpoints].x = p->x;
6095 1 : self->point[self->numpoints].y = p->y;
6096 1 : self->numpoints++;
6097 :
6098 : return MS_SUCCESS;
6099 : }
6100 : SWIGINTERN int lineObj_set(lineObj *self,int i,pointObj *p){
6101 0 : if (i<0 || i>=self->numpoints)
6102 : return MS_FAILURE;
6103 :
6104 0 : self->point[i].x = p->x;
6105 0 : self->point[i].y = p->y;
6106 : return MS_SUCCESS;
6107 : }
6108 1 : SWIGINTERN shapeObj *new_shapeObj(int type){
6109 : shapeObj *shape;
6110 :
6111 1 : shape = (shapeObj *)malloc(sizeof(shapeObj));
6112 1 : if (!shape)
6113 : return NULL;
6114 :
6115 1 : msInitShape(shape);
6116 1 : if(type >= 0) shape->type = type;
6117 :
6118 : return shape;
6119 : }
6120 : SWIGINTERN void delete_shapeObj(shapeObj *self){
6121 1 : msFreeShape(self);
6122 1 : free(self);
6123 : }
6124 : SWIGINTERN shapeObj *shapeObj_fromWKT(char *wkt){
6125 : shapeObj *shape;
6126 :
6127 1 : if(!wkt) return NULL;
6128 :
6129 1 : shape = msShapeFromWKT(wkt);
6130 1 : if(!shape) return NULL;
6131 :
6132 : return shape;
6133 : }
6134 : SWIGINTERN int shapeObj_project(shapeObj *self,projectionObj *projin,projectionObj *projout){
6135 1 : return msProjectShape(projin, projout, self);
6136 : }
6137 : SWIGINTERN lineObj *shapeObj_get(shapeObj *self,int i){
6138 1 : if (i<0 || i>=self->numlines)
6139 : return NULL;
6140 : else
6141 1 : return &(self->line[i]);
6142 : }
6143 : SWIGINTERN int shapeObj_add(shapeObj *self,lineObj *line){
6144 1 : return msAddLine(self, line);
6145 : }
6146 : SWIGINTERN int shapeObj_draw(shapeObj *self,mapObj *map,layerObj *layer,imageObj *image){
6147 0 : return msDrawShape(map, layer, self, image, -1, MS_DRAWMODE_FEATURES|MS_DRAWMODE_LABELS);
6148 : }
6149 : SWIGINTERN void shapeObj_setBounds(shapeObj *self){
6150 1 : msComputeBounds(self);
6151 : return;
6152 : }
6153 1 : SWIGINTERN shapeObj *shapeObj_clone(shapeObj *self){
6154 : shapeObj *shape;
6155 1 : shape = (shapeObj *)malloc(sizeof(shapeObj));
6156 1 : if (!shape)
6157 : return NULL;
6158 1 : msInitShape(shape);
6159 1 : shape->type = self->type;
6160 1 : msCopyShape(self, shape);
6161 1 : return shape;
6162 : }
6163 : SWIGINTERN int shapeObj_copy(shapeObj *self,shapeObj *dest){
6164 0 : return(msCopyShape(self, dest));
6165 : }
6166 : SWIGINTERN char *shapeObj_toWKT(shapeObj *self){
6167 1 : return msShapeToWKT(self);
6168 : }
6169 0 : SWIGINTERN shapeObj *shapeObj_buffer(shapeObj *self,double width){ return msGEOSBuffer(self, width); }
6170 0 : SWIGINTERN shapeObj *shapeObj_simplify(shapeObj *self,double tolerance){ return msGEOSSimplify(self, tolerance); }
6171 0 : SWIGINTERN shapeObj *shapeObj_topologyPreservingSimplify(shapeObj *self,double tolerance){ return msGEOSTopologyPreservingSimplify(self, tolerance); }
6172 0 : SWIGINTERN shapeObj *shapeObj_convexHull(shapeObj *self){ return msGEOSConvexHull(self); }
6173 0 : SWIGINTERN shapeObj *shapeObj_boundary(shapeObj *self){ return msGEOSBoundary(self); }
6174 0 : SWIGINTERN pointObj *shapeObj_getCentroid(shapeObj *self){ return msGEOSGetCentroid(self); }
6175 0 : SWIGINTERN shapeObj *shapeObj_Union(shapeObj *self,shapeObj *shape){ return msGEOSUnion(self, shape); }
6176 0 : SWIGINTERN shapeObj *shapeObj_intersection(shapeObj *self,shapeObj *shape){ return msGEOSIntersection(self, shape); }
6177 0 : SWIGINTERN shapeObj *shapeObj_difference(shapeObj *self,shapeObj *shape){ return msGEOSDifference(self, shape); }
6178 0 : SWIGINTERN shapeObj *shapeObj_symDifference(shapeObj *self,shapeObj *shape){ return msGEOSSymDifference(self, shape); }
6179 0 : SWIGINTERN int shapeObj_contains__SWIG_0(shapeObj *self,shapeObj *shape){ return msGEOSContains(self, shape); }
6180 0 : SWIGINTERN int shapeObj_overlaps(shapeObj *self,shapeObj *shape){ return msGEOSOverlaps(self, shape); }
6181 0 : SWIGINTERN int shapeObj_within(shapeObj *self,shapeObj *shape){ return msGEOSWithin(self, shape); }
6182 0 : SWIGINTERN int shapeObj_crosses(shapeObj *self,shapeObj *shape){ return msGEOSCrosses(self, shape); }
6183 0 : SWIGINTERN int shapeObj_intersects(shapeObj *self,shapeObj *shape){ return msGEOSIntersects(self, shape); }
6184 0 : SWIGINTERN int shapeObj_touches(shapeObj *self,shapeObj *shape){ return msGEOSTouches(self, shape); }
6185 0 : SWIGINTERN int shapeObj_equals(shapeObj *self,shapeObj *shape){ return msGEOSEquals(self, shape); }
6186 0 : SWIGINTERN int shapeObj_disjoint(shapeObj *self,shapeObj *shape){ return msGEOSDisjoint(self, shape); }
6187 0 : SWIGINTERN double shapeObj_getArea(shapeObj *self){ return msGEOSArea(self); }
6188 0 : SWIGINTERN double shapeObj_getLength(shapeObj *self){ return msGEOSLength(self); }
6189 : SWIGINTERN char *shapeObj_getValue(shapeObj *self,int i){
6190 1 : if (i >= 0 && i < self->numvalues && self->values)
6191 1 : return (self->values[i]);
6192 : else
6193 : return NULL;
6194 : }
6195 : SWIGINTERN int shapeObj_contains__SWIG_1(shapeObj *self,pointObj *point){
6196 0 : if (self->type == MS_SHAPE_POLYGON)
6197 0 : return msIntersectPointPolygon(point, self);
6198 :
6199 : return -1;
6200 : }
6201 : SWIGINTERN double shapeObj_distanceToPoint(shapeObj *self,pointObj *point){
6202 0 : return msDistancePointToShape(point, self); /* should there be a GEOS version of this? */
6203 : }
6204 : SWIGINTERN double shapeObj_distanceToShape(shapeObj *self,shapeObj *shape){
6205 0 : return msGEOSDistance(self, shape); /* note this calls msDistanceShapeToShape() if GEOS support is not present */
6206 : }
6207 0 : SWIGINTERN pointObj *shapeObj_getLabelPoint(shapeObj *self){
6208 0 : pointObj *point = (pointObj *)calloc(1, sizeof(pointObj));
6209 0 : if (point == NULL) {
6210 0 : msSetError(2, "Failed to allocate memory for point", "labelPoint()");
6211 0 : return NULL;
6212 : }
6213 :
6214 0 : if(self->type == MS_SHAPE_POLYGON && msPolygonLabelPoint(self, point, -1) == MS_SUCCESS)
6215 : return point;
6216 :
6217 0 : free(point);
6218 0 : return NULL;
6219 : }
6220 1 : SWIGINTERN int shapeObj_setValue(shapeObj *self,int i,char *value){
6221 1 : if (!self->values || !value)
6222 : {
6223 0 : msSetError(19, "Can't set value", "setValue()");
6224 : return MS_FAILURE;
6225 : }
6226 1 : if (i >= 0 && i < self->numvalues)
6227 : {
6228 1 : msFree(self->values[i]);
6229 1 : self->values[i] = msStrdup(value);
6230 1 : if (!self->values[i])
6231 : {
6232 : return MS_FAILURE;
6233 : }
6234 : else return MS_SUCCESS;
6235 : }
6236 : else
6237 : {
6238 0 : msSetError(19, "Invalid value index",
6239 : "setValue()");
6240 : return MS_FAILURE;
6241 : }
6242 : }
6243 1 : SWIGINTERN void shapeObj_initValues(shapeObj *self,int numvalues){
6244 : int i;
6245 :
6246 1 : if(self->values) msFreeCharArray(self->values, self->numvalues);
6247 1 : self->values = NULL;
6248 1 : self->numvalues = 0;
6249 :
6250 : /* Allocate memory for the values */
6251 1 : if (numvalues > 0) {
6252 1 : if ((self->values = (char **)malloc(sizeof(char *)*numvalues)) == NULL) {
6253 0 : msSetError(2, "Failed to allocate memory for values", "shapeObj()");
6254 : return;
6255 : } else {
6256 1 : for (i=0; i<numvalues; i++) self->values[i] = msStrdup("");
6257 : }
6258 1 : self->numvalues = numvalues;
6259 : }
6260 : }
6261 :
6262 : SWIGINTERN size_t
6263 : SWIG_strnlen(const char* s, size_t maxlen)
6264 : {
6265 : const char *p;
6266 0 : for (p = s; maxlen-- && *p; p++)
6267 : ;
6268 0 : return p - s;
6269 : }
6270 :
6271 : SWIGINTERN struct errorObj *new_errorObj(void){
6272 0 : return msGetErrorObj();
6273 : }
6274 : SWIGINTERN void delete_errorObj(struct errorObj *self){}
6275 0 : SWIGINTERN errorObj *errorObj_next(struct errorObj *self){
6276 : errorObj *ep;
6277 :
6278 0 : if (self == NULL || self->next == NULL) return NULL;
6279 :
6280 0 : ep = msGetErrorObj();
6281 0 : while (ep != self) {
6282 : /* We reached end of list of active errorObj and
6283 : didn't find the errorObj... this is bad! */
6284 0 : if (ep->next == NULL) return NULL;
6285 : ep = ep->next;
6286 : }
6287 :
6288 0 : return ep->next;
6289 : }
6290 : SWIGINTERN char *DBFInfo_getFieldName(DBFInfo *self,int iField){
6291 : static char pszFieldName[1000];
6292 : int pnWidth;
6293 : int pnDecimals;
6294 1 : msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth,
6295 : &pnDecimals);
6296 : return pszFieldName;
6297 : }
6298 1 : SWIGINTERN int DBFInfo_getFieldWidth(DBFInfo *self,int iField){
6299 : char pszFieldName[1000];
6300 : int pnWidth;
6301 : int pnDecimals;
6302 1 : msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth,
6303 : &pnDecimals);
6304 1 : return pnWidth;
6305 : }
6306 1 : SWIGINTERN int DBFInfo_getFieldDecimals(DBFInfo *self,int iField){
6307 : char pszFieldName[1000];
6308 : int pnWidth;
6309 : int pnDecimals;
6310 1 : msDBFGetFieldInfo(self, iField, &pszFieldName[0], &pnWidth,
6311 : &pnDecimals);
6312 1 : return pnDecimals;
6313 : }
6314 : SWIGINTERN int DBFInfo_getFieldType(DBFInfo *self,int iField){
6315 1 : return msDBFGetFieldInfo(self, iField, NULL, NULL, NULL);
6316 : }
6317 1 : SWIGINTERN shapefileObj *new_shapefileObj(char *filename,int type){
6318 : shapefileObj *shapefile;
6319 : int status;
6320 :
6321 1 : shapefile = (shapefileObj *)malloc(sizeof(shapefileObj));
6322 1 : if (!shapefile)
6323 : return NULL;
6324 :
6325 1 : if (type == -1)
6326 1 : status = msShapefileOpen(shapefile, "rb", filename, 1);
6327 1 : else if (type == -2)
6328 0 : status = msShapefileOpen(shapefile, "rb+", filename, 1);
6329 : else
6330 1 : status = msShapefileCreate(shapefile, filename, type);
6331 :
6332 1 : if (status == -1) {
6333 0 : msShapefileClose(shapefile);
6334 0 : free(shapefile);
6335 0 : return NULL;
6336 : }
6337 :
6338 : return(shapefile);
6339 : }
6340 : SWIGINTERN void delete_shapefileObj(shapefileObj *self){
6341 1 : msShapefileClose(self);
6342 1 : free(self);
6343 : }
6344 1 : SWIGINTERN int shapefileObj_get(shapefileObj *self,int i,shapeObj *shape){
6345 1 : if (i<0 || i>=self->numshapes)
6346 : return MS_FAILURE;
6347 :
6348 1 : msFreeShape(shape); /* frees all lines and points before re-filling */
6349 1 : msSHPReadShape(self->hSHP, i, shape);
6350 :
6351 : return MS_SUCCESS;
6352 : }
6353 0 : SWIGINTERN shapeObj *shapefileObj_getShape(shapefileObj *self,int i){
6354 : shapeObj *shape;
6355 0 : shape = (shapeObj *)malloc(sizeof(shapeObj));
6356 0 : if (!shape)
6357 : return NULL;
6358 0 : msInitShape(shape);
6359 0 : shape->type = self->type;
6360 0 : msSHPReadShape(self->hSHP, i, shape);
6361 : return shape;
6362 :
6363 : }
6364 : SWIGINTERN int shapefileObj_getPoint(shapefileObj *self,int i,pointObj *point){
6365 0 : if (i<0 || i>=self->numshapes)
6366 : return MS_FAILURE;
6367 :
6368 0 : msSHPReadPoint(self->hSHP, i, point);
6369 : return MS_SUCCESS;
6370 : }
6371 0 : SWIGINTERN int shapefileObj_getTransformed(shapefileObj *self,mapObj *map,int i,shapeObj *shape){
6372 0 : if (i<0 || i>=self->numshapes)
6373 : return MS_FAILURE;
6374 :
6375 0 : msFreeShape(shape); /* frees all lines and points before re-filling */
6376 0 : msSHPReadShape(self->hSHP, i, shape);
6377 0 : msTransformShapeSimplify(shape, map->extent, map->cellsize);
6378 :
6379 : return MS_SUCCESS;
6380 : }
6381 : SWIGINTERN void shapefileObj_getExtent(shapefileObj *self,int i,rectObj *rect){
6382 0 : msSHPReadBounds(self->hSHP, i, rect);
6383 : }
6384 1 : SWIGINTERN int shapefileObj_add(shapefileObj *self,shapeObj *shape){
6385 : /* Trap NULL or empty shapes -- bug 1201 */
6386 1 : if (!shape)
6387 : {
6388 0 : msSetError(19, "Can't add NULL shape", "shapefileObj::add");
6389 : return MS_FAILURE;
6390 : }
6391 1 : else if (!shape->line)
6392 : {
6393 1 : msSetError(19, "Can't add empty shape", "shapefileObj::add");
6394 : return MS_FAILURE;
6395 : }
6396 :
6397 0 : return msSHPWriteShape(self->hSHP, shape);
6398 : }
6399 : SWIGINTERN int shapefileObj_addPoint(shapefileObj *self,pointObj *point){
6400 0 : return msSHPWritePoint(self->hSHP, point);
6401 : }
6402 : SWIGINTERN DBFInfo *shapefileObj_getDBF(shapefileObj *self){
6403 : return self->hDBF;
6404 : }
6405 1 : SWIGINTERN projectionObj *new_projectionObj(char *proj4){
6406 : int status;
6407 : projectionObj *proj=NULL;
6408 :
6409 1 : proj = (projectionObj *)malloc(sizeof(projectionObj));
6410 1 : if (!proj) return NULL;
6411 1 : msInitProjection(proj);
6412 :
6413 1 : status = msLoadProjectionString(proj, proj4);
6414 1 : if (status == -1) {
6415 0 : msFreeProjection(proj);
6416 0 : free(proj);
6417 0 : return NULL;
6418 : }
6419 :
6420 : return proj;
6421 : }
6422 : SWIGINTERN void delete_projectionObj(projectionObj *self){
6423 1 : msFreeProjection(self);
6424 1 : free(self);
6425 : }
6426 : SWIGINTERN int projectionObj_setWKTProjection(projectionObj *self,char *wkt){
6427 : /* no debug output here */
6428 0 : return msOGCWKT2ProjectionObj(wkt, self, 0);
6429 : }
6430 : SWIGINTERN int projectionObj_getUnits(projectionObj *self){
6431 1 : return GetMapserverUnitUsingProj(self);
6432 : }
6433 1 : SWIGINTERN colorObj *new_colorObj(int red,int green,int blue,int alpha){
6434 : colorObj *color;
6435 :
6436 : /* Check colors */
6437 1 : if (red > 255 || green > 255 || blue > 255 || alpha>255 ||
6438 1 : red<-1 || green<-1 || blue<-1 || alpha<0 ) {
6439 0 : msSetError(12, "Invalid color", "colorObj()");
6440 0 : return NULL;
6441 : }
6442 :
6443 1 : color = (colorObj *)calloc(1, sizeof(colorObj));
6444 1 : if (!color)
6445 : return(NULL);
6446 :
6447 1 : MS_INIT_COLOR(*color, red, green, blue, alpha);
6448 :
6449 1 : return(color);
6450 : }
6451 : SWIGINTERN void delete_colorObj(colorObj *self){
6452 1 : free(self);
6453 : }
6454 1 : SWIGINTERN int colorObj_setRGB(colorObj *self,int red,int green,int blue,int alpha){
6455 : /* Check colors */
6456 1 : if (red > 255 || green > 255 || blue > 255 || alpha > 255) {
6457 0 : msSetError(12, "Invalid color index.", "setRGB()");
6458 0 : return MS_FAILURE;
6459 : }
6460 :
6461 1 : MS_INIT_COLOR(*self, red, green, blue, alpha);
6462 1 : return MS_SUCCESS;
6463 : }
6464 1 : SWIGINTERN int colorObj_setHex(colorObj *self,char *psHexColor){
6465 : int red, green, blue, alpha = 255;
6466 1 : if (psHexColor && (strlen(psHexColor) == 7 || strlen(psHexColor) == 9) && psHexColor[0] == '#') {
6467 1 : red = msHexToInt(psHexColor+1);
6468 1 : green = msHexToInt(psHexColor+3);
6469 1 : blue= msHexToInt(psHexColor+5);
6470 1 : if (strlen(psHexColor) == 9) {
6471 1 : alpha = msHexToInt(psHexColor+7);
6472 : }
6473 1 : if (red > 255 || green > 255 || blue > 255 || alpha > 255) {
6474 1 : msSetError(12, "Invalid color index.", "setHex()");
6475 1 : return MS_FAILURE;
6476 : }
6477 :
6478 1 : MS_INIT_COLOR(*self, red, green, blue, alpha);
6479 1 : return MS_SUCCESS;
6480 : }
6481 : else {
6482 0 : msSetError(12, "Invalid hex color.", "setHex()");
6483 0 : return MS_FAILURE;
6484 : }
6485 : }
6486 1 : SWIGINTERN char *colorObj_toHex(colorObj *self){
6487 : char *hexcolor;
6488 :
6489 1 : if (!self)
6490 : {
6491 0 : msSetError(12, "Can't express NULL color as hex",
6492 : "toHex()");
6493 0 : return NULL;
6494 : }
6495 1 : if (self->red < 0 || self->green < 0 || self->blue < 0)
6496 : {
6497 1 : msSetError(12, "Can't express invalid color as hex",
6498 : "toHex()");
6499 1 : return NULL;
6500 : }
6501 1 : if (self->alpha == 255) {
6502 1 : hexcolor = msSmallMalloc(8);
6503 1 : snprintf(hexcolor, 8, "#%02x%02x%02x",
6504 : self->red, self->green, self->blue);
6505 0 : } else if (self->alpha >= 0) {
6506 0 : hexcolor = msSmallMalloc(10);
6507 0 : snprintf(hexcolor, 10, "#%02x%02x%02x%02x",
6508 : self->red, self->green, self->blue, self->alpha);
6509 : } else {
6510 0 : msSetError(12, "Can't express color with invalid alpha as hex",
6511 : "toHex()");
6512 0 : return NULL;
6513 : }
6514 : return hexcolor;
6515 : }
6516 1 : SWIGINTERN struct symbolObj *new_symbolObj(char *symbolname,char const *imagefile){
6517 : symbolObj *symbol;
6518 1 : symbol = (symbolObj *) malloc(sizeof(symbolObj));
6519 1 : initSymbol(symbol);
6520 1 : symbol->name = msStrdup(symbolname);
6521 1 : if (imagefile) {
6522 1 : msLoadImageSymbol(symbol, imagefile);
6523 : }
6524 1 : return symbol;
6525 : }
6526 1 : SWIGINTERN void delete_symbolObj(struct symbolObj *self){
6527 1 : if (self) {
6528 1 : if (msFreeSymbol(self)==MS_SUCCESS) {
6529 1 : free(self);
6530 : self=NULL;
6531 : }
6532 : }
6533 1 : }
6534 : SWIGINTERN int symbolObj_setImagepath(struct symbolObj *self,char const *imagefile){
6535 1 : return msLoadImageSymbol(self, imagefile);
6536 : }
6537 : SWIGINTERN int symbolObj_setPoints(struct symbolObj *self,lineObj *line){
6538 : int i;
6539 1 : self->sizex = 0;
6540 1 : self->sizey = 0;
6541 1 : for (i=0; i<line->numpoints; i++) {
6542 1 : MS_COPYPOINT(&(self->points[i]), &(line->point[i]));
6543 1 : self->sizex = MS_MAX(self->sizex, self->points[i].x);
6544 1 : self->sizey = MS_MAX(self->sizey, self->points[i].y);
6545 : }
6546 1 : self->numpoints = line->numpoints;
6547 : return self->numpoints;
6548 : }
6549 1 : SWIGINTERN lineObj *symbolObj_getPoints(struct symbolObj *self){
6550 : int i;
6551 : lineObj *line;
6552 1 : line = (lineObj *) malloc(sizeof(lineObj));
6553 1 : line->point = (pointObj *) malloc(sizeof(pointObj)*(self->numpoints));
6554 1 : for (i=0; i<self->numpoints; i++) {
6555 1 : line->point[i].x = self->points[i].x;
6556 1 : line->point[i].y = self->points[i].y;
6557 : }
6558 1 : line->numpoints = self->numpoints;
6559 1 : return line;
6560 : }
6561 1 : SWIGINTERN imageObj *symbolObj_getImage(struct symbolObj *self,outputFormatObj *input_format){
6562 : imageObj *image = NULL;
6563 : outputFormatObj *format = NULL;
6564 : rendererVTableObj *renderer = NULL;
6565 :
6566 1 : if (input_format)
6567 : {
6568 : format = input_format;
6569 : }
6570 : else
6571 : {
6572 0 : format = msCreateDefaultOutputFormat(NULL, "AGG/PNG", "aggpng");
6573 0 : if (format)
6574 0 : msInitializeRendererVTable(format);
6575 : }
6576 :
6577 1 : if (format == NULL)
6578 : {
6579 0 : msSetError(15, "Could not create output format",
6580 : "getImage()");
6581 0 : return NULL;
6582 : }
6583 :
6584 1 : renderer = format->vtable;
6585 1 : msPreloadImageSymbol(renderer, self);
6586 1 : if (self->pixmap_buffer)
6587 : {
6588 1 : image = msImageCreate(self->pixmap_buffer->width, self->pixmap_buffer->height, format, NULL, NULL,
6589 : MS_DEFAULT_RESOLUTION, MS_DEFAULT_RESOLUTION, NULL);
6590 1 : if(!image) {
6591 0 : msSetError(15, "Could not create image",
6592 : "getImage()");
6593 0 : return NULL;
6594 : }
6595 1 : if(MS_SUCCESS != renderer->mergeRasterBuffer(image, self->pixmap_buffer, 1.0, 0, 0, 0, 0,
6596 1 : self->pixmap_buffer->width, self->pixmap_buffer->height)) {
6597 0 : msSetError(15, "Could not merge symbol image",
6598 : "getImage()");
6599 0 : msFreeImage(image);
6600 0 : return NULL;
6601 : }
6602 : }
6603 :
6604 : return image;
6605 : }
6606 0 : SWIGINTERN int symbolObj_setImage(struct symbolObj *self,imageObj *image){
6607 : rendererVTableObj *renderer = NULL;
6608 :
6609 0 : renderer = image->format->vtable;
6610 :
6611 0 : if (self->pixmap_buffer) {
6612 0 : msFreeRasterBuffer(self->pixmap_buffer);
6613 0 : free(self->pixmap_buffer);
6614 : }
6615 :
6616 0 : self->pixmap_buffer = (rasterBufferObj*)malloc(sizeof(rasterBufferObj));
6617 0 : if (!self->pixmap_buffer) {
6618 0 : msSetError(2, NULL, "setImage()");
6619 : return MS_FAILURE;
6620 : }
6621 0 : self->type = MS_SYMBOL_PIXMAP;
6622 0 : return renderer->getRasterBufferCopy(image, self->pixmap_buffer);
6623 : }
6624 : SWIGINTERN hashTableObj *new_hashTableObj(void){
6625 :
6626 1 : return msCreateHashTable();
6627 : }
6628 : SWIGINTERN void delete_hashTableObj(hashTableObj *self){
6629 1 : msFreeHashTable(self);
6630 : }
6631 : SWIGINTERN int hashTableObj_set(hashTableObj *self,char *key,char *value){
6632 1 : if (msInsertHashTable(self, key, value) == NULL) {
6633 : return MS_FAILURE;
6634 : }
6635 : return MS_SUCCESS;
6636 : }
6637 1 : SWIGINTERN char *hashTableObj_get(hashTableObj *self,char *key,char *default_value){
6638 : char *value = NULL;
6639 1 : if (!key) {
6640 0 : msSetError(16, "NULL key", "get");
6641 : }
6642 :
6643 1 : value = (char *) msLookupHashTable(self, key);
6644 1 : if (!value) {
6645 : return default_value;
6646 : }
6647 1 : return value;
6648 : }
6649 : SWIGINTERN int hashTableObj_remove(hashTableObj *self,char *key){
6650 1 : return msRemoveHashTable(self, key);
6651 : }
6652 : SWIGINTERN void hashTableObj_clear(hashTableObj *self){
6653 1 : msFreeHashItems(self);
6654 1 : initHashTable(self);
6655 : }
6656 : SWIGINTERN char const *hashTableObj_nextKey(hashTableObj *self,char *prevkey){
6657 1 : return msNextKeyFromHashTable(self, (const char *) prevkey);
6658 : }
6659 :
6660 1 : static char *msGetEnvURL( const char *key, void *thread_context )
6661 : {
6662 1 : if( strcmp(key,"REQUEST_METHOD") == 0 )
6663 : return "GET";
6664 :
6665 1 : if( strcmp(key,"QUERY_STRING") == 0 )
6666 : return (char *) thread_context;
6667 :
6668 1 : return NULL;
6669 : }
6670 :
6671 1 : SWIGINTERN cgiRequestObj *new_cgiRequestObj(void){
6672 : cgiRequestObj *request;
6673 :
6674 1 : request = msAllocCgiObj();
6675 1 : if (!request) {
6676 0 : msSetError(13, "Failed to initialize object","OWSRequest()");
6677 0 : return NULL;
6678 : }
6679 :
6680 : return request;
6681 : }
6682 : SWIGINTERN void delete_cgiRequestObj(cgiRequestObj *self){
6683 1 : msFreeCgiObj(self);
6684 : }
6685 : SWIGINTERN int cgiRequestObj_loadParams(cgiRequestObj *self){
6686 0 : self->NumParams = loadParams( self, NULL, NULL, 0, NULL);
6687 : return self->NumParams;
6688 : }
6689 : SWIGINTERN int cgiRequestObj_loadParamsFromURL(cgiRequestObj *self,char const *url){
6690 1 : self->NumParams = loadParams( self, msGetEnvURL, NULL, 0, (void*)url );
6691 : return self->NumParams;
6692 : }
6693 1 : SWIGINTERN void cgiRequestObj_setParameter(cgiRequestObj *self,char *name,char *value){
6694 : int i;
6695 :
6696 1 : if (self->NumParams == 100) {
6697 0 : msSetError(31, "Maximum number of items, %d, has been reached", "setItem()", 100);
6698 : }
6699 :
6700 1 : for (i=0; i<self->NumParams; i++) {
6701 1 : if (strcasecmp(self->ParamNames[i], name) == 0) {
6702 1 : free(self->ParamValues[i]);
6703 1 : self->ParamValues[i] = msStrdup(value);
6704 1 : break;
6705 : }
6706 : }
6707 1 : if (i == self->NumParams) {
6708 1 : self->ParamNames[self->NumParams] = msStrdup(name);
6709 1 : self->ParamValues[self->NumParams] = msStrdup(value);
6710 1 : self->NumParams++;
6711 : }
6712 1 : }
6713 0 : SWIGINTERN void cgiRequestObj_addParameter(cgiRequestObj *self,char *name,char *value){
6714 0 : if (self->NumParams == 100) {
6715 0 : msSetError(31, "Maximum number of items, %d, has been reached", "addParameter()", 100);
6716 : }
6717 0 : self->ParamNames[self->NumParams] = msStrdup(name);
6718 0 : self->ParamValues[self->NumParams] = msStrdup(value);
6719 0 : self->NumParams++;
6720 0 : }
6721 1 : SWIGINTERN char *cgiRequestObj_getName(cgiRequestObj *self,int index){
6722 1 : if (index < 0 || index >= self->NumParams) {
6723 0 : msSetError(31, "Invalid index, valid range is [0, %d]", "getName()", self->NumParams-1);
6724 : return NULL;
6725 : }
6726 1 : return self->ParamNames[index];
6727 : }
6728 1 : SWIGINTERN char *cgiRequestObj_getValue(cgiRequestObj *self,int index){
6729 1 : if (index < 0 || index >= self->NumParams) {
6730 0 : msSetError(31, "Invalid index, valid range is [0, %d]", "getValue()", self->NumParams-1);
6731 : return NULL;
6732 : }
6733 1 : return self->ParamValues[index];
6734 : }
6735 1 : SWIGINTERN char *cgiRequestObj_getValueByName(cgiRequestObj *self,char const *name){
6736 : int i;
6737 1 : for (i=0; i<self->NumParams; i++) {
6738 1 : if (strcasecmp(self->ParamNames[i], name) == 0) {
6739 1 : return self->ParamValues[i];
6740 : }
6741 : }
6742 : return NULL;
6743 : }
6744 :
6745 :
6746 0 : const char *msIO_getStdoutBufferString() {
6747 0 : msIOContext *ctx = msIO_getHandler( (FILE *) "stdout" );
6748 : msIOBuffer *buf;
6749 :
6750 0 : if( ctx == NULL || ctx->write_channel == MS_FALSE
6751 0 : || strcmp(ctx->label,"buffer") != 0 )
6752 : {
6753 0 : msSetError( MS_MISCERR, "Can't identify msIO buffer.",
6754 : "msIO_getStdoutBufferString" );
6755 0 : return "";
6756 : }
6757 :
6758 0 : buf = (msIOBuffer *) ctx->cbData;
6759 :
6760 : /* write one zero byte and backtrack if it isn't already there */
6761 0 : if( buf->data_len == 0 || buf->data[buf->data_offset] != '\0' ) {
6762 0 : msIO_bufferWrite( buf, "", 1 );
6763 0 : buf->data_offset--;
6764 : }
6765 :
6766 0 : return (const char *) (buf->data);
6767 : }
6768 :
6769 1 : gdBuffer msIO_getStdoutBufferBytes() {
6770 1 : msIOContext *ctx = msIO_getHandler( (FILE *) "stdout" );
6771 : msIOBuffer *buf;
6772 : gdBuffer gdBuf;
6773 :
6774 1 : if( ctx == NULL || ctx->write_channel == MS_FALSE
6775 1 : || strcmp(ctx->label,"buffer") != 0 )
6776 : {
6777 0 : msSetError( MS_MISCERR, "Can't identify msIO buffer.",
6778 : "msIO_getStdoutBufferString" );
6779 : gdBuf.data = (unsigned char*)"";
6780 : gdBuf.size = 0;
6781 : gdBuf.owns_data = MS_FALSE;
6782 0 : return gdBuf;
6783 : }
6784 :
6785 1 : buf = (msIOBuffer *) ctx->cbData;
6786 :
6787 1 : gdBuf.data = buf->data;
6788 1 : gdBuf.size = buf->data_offset;
6789 : gdBuf.owns_data = MS_TRUE;
6790 :
6791 : /* we are seizing ownership of the buffer contents */
6792 1 : buf->data_offset = 0;
6793 1 : buf->data_len = 0;
6794 1 : buf->data = NULL;
6795 :
6796 1 : return gdBuf;
6797 : }
6798 :
6799 :
6800 : #ifdef __cplusplus
6801 : extern "C" {
6802 : #endif
6803 0 : SWIGINTERN PyObject *_wrap_new_intarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6804 : PyObject *resultobj = 0;
6805 : size_t arg1 ;
6806 : size_t val1 ;
6807 : int ecode1 = 0 ;
6808 0 : PyObject * obj0 = 0 ;
6809 : intarray *result = 0 ;
6810 :
6811 0 : if (!PyArg_ParseTuple(args,(char *)"O:new_intarray",&obj0)) SWIG_fail;
6812 0 : ecode1 = SWIG_AsVal_size_t(obj0, &val1);
6813 0 : if (!SWIG_IsOK(ecode1)) {
6814 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_intarray" "', argument " "1"" of type '" "size_t""'");
6815 : }
6816 : arg1 = (size_t)(val1);
6817 : result = (intarray *)new_intarray(arg1);
6818 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, SWIG_POINTER_NEW | 0 );
6819 0 : return resultobj;
6820 0 : fail:
6821 : return NULL;
6822 : }
6823 :
6824 :
6825 0 : SWIGINTERN PyObject *_wrap_delete_intarray(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6826 : PyObject *resultobj = 0;
6827 : intarray *arg1 = (intarray *) 0 ;
6828 0 : void *argp1 = 0 ;
6829 : int res1 = 0 ;
6830 0 : PyObject * obj0 = 0 ;
6831 :
6832 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_intarray",&obj0)) SWIG_fail;
6833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, SWIG_POINTER_DISOWN | 0 );
6834 0 : if (!SWIG_IsOK(res1)) {
6835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_intarray" "', argument " "1"" of type '" "intarray *""'");
6836 : }
6837 0 : arg1 = (intarray *)(argp1);
6838 : delete_intarray(arg1);
6839 : resultobj = SWIG_Py_Void();
6840 0 : return resultobj;
6841 0 : fail:
6842 : return NULL;
6843 : }
6844 :
6845 :
6846 0 : SWIGINTERN PyObject *_wrap_intarray___getitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6847 : PyObject *resultobj = 0;
6848 : intarray *arg1 = (intarray *) 0 ;
6849 : size_t arg2 ;
6850 0 : void *argp1 = 0 ;
6851 : int res1 = 0 ;
6852 : size_t val2 ;
6853 : int ecode2 = 0 ;
6854 0 : PyObject * obj0 = 0 ;
6855 0 : PyObject * obj1 = 0 ;
6856 : int result;
6857 :
6858 0 : if (!PyArg_ParseTuple(args,(char *)"OO:intarray___getitem__",&obj0,&obj1)) SWIG_fail;
6859 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 | 0 );
6860 0 : if (!SWIG_IsOK(res1)) {
6861 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray___getitem__" "', argument " "1"" of type '" "intarray *""'");
6862 : }
6863 0 : arg1 = (intarray *)(argp1);
6864 0 : ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6865 0 : if (!SWIG_IsOK(ecode2)) {
6866 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intarray___getitem__" "', argument " "2"" of type '" "size_t""'");
6867 : }
6868 : arg2 = (size_t)(val2);
6869 : result = (int)intarray___getitem__(arg1,arg2);
6870 : resultobj = SWIG_From_int((int)(result));
6871 0 : return resultobj;
6872 0 : fail:
6873 : return NULL;
6874 : }
6875 :
6876 :
6877 0 : SWIGINTERN PyObject *_wrap_intarray___setitem__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6878 : PyObject *resultobj = 0;
6879 : intarray *arg1 = (intarray *) 0 ;
6880 : size_t arg2 ;
6881 : int arg3 ;
6882 0 : void *argp1 = 0 ;
6883 : int res1 = 0 ;
6884 : size_t val2 ;
6885 : int ecode2 = 0 ;
6886 : int val3 ;
6887 : int ecode3 = 0 ;
6888 0 : PyObject * obj0 = 0 ;
6889 0 : PyObject * obj1 = 0 ;
6890 0 : PyObject * obj2 = 0 ;
6891 :
6892 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:intarray___setitem__",&obj0,&obj1,&obj2)) SWIG_fail;
6893 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 | 0 );
6894 0 : if (!SWIG_IsOK(res1)) {
6895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray___setitem__" "', argument " "1"" of type '" "intarray *""'");
6896 : }
6897 0 : arg1 = (intarray *)(argp1);
6898 0 : ecode2 = SWIG_AsVal_size_t(obj1, &val2);
6899 0 : if (!SWIG_IsOK(ecode2)) {
6900 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "intarray___setitem__" "', argument " "2"" of type '" "size_t""'");
6901 : }
6902 : arg2 = (size_t)(val2);
6903 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
6904 0 : if (!SWIG_IsOK(ecode3)) {
6905 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "intarray___setitem__" "', argument " "3"" of type '" "int""'");
6906 : }
6907 : arg3 = (int)(val3);
6908 : intarray___setitem__(arg1,arg2,arg3);
6909 : resultobj = SWIG_Py_Void();
6910 0 : return resultobj;
6911 0 : fail:
6912 : return NULL;
6913 : }
6914 :
6915 :
6916 0 : SWIGINTERN PyObject *_wrap_intarray_cast(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6917 : PyObject *resultobj = 0;
6918 : intarray *arg1 = (intarray *) 0 ;
6919 0 : void *argp1 = 0 ;
6920 : int res1 = 0 ;
6921 0 : PyObject * obj0 = 0 ;
6922 : int *result = 0 ;
6923 :
6924 0 : if (!PyArg_ParseTuple(args,(char *)"O:intarray_cast",&obj0)) SWIG_fail;
6925 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_intarray, 0 | 0 );
6926 0 : if (!SWIG_IsOK(res1)) {
6927 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray_cast" "', argument " "1"" of type '" "intarray *""'");
6928 : }
6929 0 : arg1 = (intarray *)(argp1);
6930 : result = (int *)intarray_cast(arg1);
6931 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
6932 0 : return resultobj;
6933 0 : fail:
6934 : return NULL;
6935 : }
6936 :
6937 :
6938 0 : SWIGINTERN PyObject *_wrap_intarray_frompointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6939 : PyObject *resultobj = 0;
6940 : int *arg1 = (int *) 0 ;
6941 0 : void *argp1 = 0 ;
6942 : int res1 = 0 ;
6943 0 : PyObject * obj0 = 0 ;
6944 : intarray *result = 0 ;
6945 :
6946 0 : if (!PyArg_ParseTuple(args,(char *)"O:intarray_frompointer",&obj0)) SWIG_fail;
6947 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_int, 0 | 0 );
6948 0 : if (!SWIG_IsOK(res1)) {
6949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "intarray_frompointer" "', argument " "1"" of type '" "int *""'");
6950 : }
6951 0 : arg1 = (int *)(argp1);
6952 : result = (intarray *)intarray_frompointer(arg1);
6953 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, 0 | 0 );
6954 0 : return resultobj;
6955 0 : fail:
6956 : return NULL;
6957 : }
6958 :
6959 :
6960 1 : SWIGINTERN PyObject *intarray_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6961 : PyObject *obj;
6962 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
6963 1 : SWIG_TypeNewClientData(SWIGTYPE_p_intarray, SWIG_NewClientData(obj));
6964 1 : return SWIG_Py_Void();
6965 : }
6966 :
6967 0 : SWIGINTERN PyObject *_wrap_CompositingFilter_filter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6968 : PyObject *resultobj = 0;
6969 : struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
6970 : char *arg2 = (char *) 0 ;
6971 0 : void *argp1 = 0 ;
6972 : int res1 = 0 ;
6973 : int res2 ;
6974 0 : char *buf2 = 0 ;
6975 0 : int alloc2 = 0 ;
6976 0 : PyObject * obj0 = 0 ;
6977 0 : PyObject * obj1 = 0 ;
6978 :
6979 0 : if (!PyArg_ParseTuple(args,(char *)"OO:CompositingFilter_filter_set",&obj0,&obj1)) SWIG_fail;
6980 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 | 0 );
6981 0 : if (!SWIG_IsOK(res1)) {
6982 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_filter_set" "', argument " "1"" of type '" "struct _CompositingFilter *""'");
6983 : }
6984 0 : arg1 = (struct _CompositingFilter *)(argp1);
6985 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6986 0 : if (!SWIG_IsOK(res2)) {
6987 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositingFilter_filter_set" "', argument " "2"" of type '" "char *""'");
6988 : }
6989 0 : arg2 = (char *)(buf2);
6990 : {
6991 0 : if (arg1->filter) free((char*)arg1->filter);
6992 0 : if (arg2) {
6993 0 : arg1->filter = (char *) malloc(strlen(arg2)+1);
6994 : strcpy((char*)arg1->filter,arg2);
6995 : } else {
6996 0 : arg1->filter = 0;
6997 : }
6998 : }
6999 : resultobj = SWIG_Py_Void();
7000 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7001 : return resultobj;
7002 0 : fail:
7003 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7004 : return NULL;
7005 : }
7006 :
7007 :
7008 0 : SWIGINTERN PyObject *_wrap_CompositingFilter_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7009 : PyObject *resultobj = 0;
7010 : struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
7011 0 : void *argp1 = 0 ;
7012 : int res1 = 0 ;
7013 0 : PyObject * obj0 = 0 ;
7014 : char *result = 0 ;
7015 :
7016 0 : if (!PyArg_ParseTuple(args,(char *)"O:CompositingFilter_filter_get",&obj0)) SWIG_fail;
7017 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 | 0 );
7018 0 : if (!SWIG_IsOK(res1)) {
7019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_filter_get" "', argument " "1"" of type '" "struct _CompositingFilter *""'");
7020 : }
7021 0 : arg1 = (struct _CompositingFilter *)(argp1);
7022 0 : result = (char *) ((arg1)->filter);
7023 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7024 0 : return resultobj;
7025 0 : fail:
7026 : return NULL;
7027 : }
7028 :
7029 :
7030 0 : SWIGINTERN PyObject *_wrap_CompositingFilter_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7031 : PyObject *resultobj = 0;
7032 : struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
7033 : struct _CompositingFilter *arg2 = (struct _CompositingFilter *) 0 ;
7034 0 : void *argp1 = 0 ;
7035 : int res1 = 0 ;
7036 0 : void *argp2 = 0 ;
7037 : int res2 = 0 ;
7038 0 : PyObject * obj0 = 0 ;
7039 0 : PyObject * obj1 = 0 ;
7040 :
7041 0 : if (!PyArg_ParseTuple(args,(char *)"OO:CompositingFilter_next_set",&obj0,&obj1)) SWIG_fail;
7042 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 | 0 );
7043 0 : if (!SWIG_IsOK(res1)) {
7044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_next_set" "', argument " "1"" of type '" "struct _CompositingFilter *""'");
7045 : }
7046 0 : arg1 = (struct _CompositingFilter *)(argp1);
7047 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN | 0 );
7048 0 : if (!SWIG_IsOK(res2)) {
7049 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "CompositingFilter_next_set" "', argument " "2"" of type '" "struct _CompositingFilter *""'");
7050 : }
7051 0 : arg2 = (struct _CompositingFilter *)(argp2);
7052 0 : if (arg1) (arg1)->next = arg2;
7053 : resultobj = SWIG_Py_Void();
7054 0 : return resultobj;
7055 0 : fail:
7056 : return NULL;
7057 : }
7058 :
7059 :
7060 0 : SWIGINTERN PyObject *_wrap_CompositingFilter_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7061 : PyObject *resultobj = 0;
7062 : struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
7063 0 : void *argp1 = 0 ;
7064 : int res1 = 0 ;
7065 0 : PyObject * obj0 = 0 ;
7066 : struct _CompositingFilter *result = 0 ;
7067 :
7068 0 : if (!PyArg_ParseTuple(args,(char *)"O:CompositingFilter_next_get",&obj0)) SWIG_fail;
7069 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, 0 | 0 );
7070 0 : if (!SWIG_IsOK(res1)) {
7071 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CompositingFilter_next_get" "', argument " "1"" of type '" "struct _CompositingFilter *""'");
7072 : }
7073 0 : arg1 = (struct _CompositingFilter *)(argp1);
7074 0 : result = (struct _CompositingFilter *) ((arg1)->next);
7075 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, 0 | 0 );
7076 0 : return resultobj;
7077 0 : fail:
7078 : return NULL;
7079 : }
7080 :
7081 :
7082 0 : SWIGINTERN PyObject *_wrap_new_CompositingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7083 : PyObject *resultobj = 0;
7084 : struct _CompositingFilter *result = 0 ;
7085 :
7086 0 : if (!PyArg_ParseTuple(args,(char *)":new_CompositingFilter")) SWIG_fail;
7087 : {
7088 0 : result = (struct _CompositingFilter *)calloc(1, sizeof(struct _CompositingFilter)); {
7089 0 : errorObj *ms_error = msGetErrorObj();
7090 :
7091 0 : switch(ms_error->code) {
7092 : case MS_NOERR:
7093 : break;
7094 0 : case MS_NOTFOUND:
7095 0 : msResetErrorList();
7096 0 : break;
7097 : case -1:
7098 : break;
7099 0 : case MS_IOERR:
7100 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7101 0 : _raise_ms_exception();
7102 0 : msResetErrorList();
7103 0 : return NULL;
7104 : }
7105 : default:
7106 0 : _raise_ms_exception();
7107 0 : msResetErrorList();
7108 0 : return NULL;
7109 : }
7110 :
7111 : }
7112 : }
7113 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, SWIG_POINTER_NEW | 0 );
7114 0 : return resultobj;
7115 0 : fail:
7116 : return NULL;
7117 : }
7118 :
7119 :
7120 0 : SWIGINTERN PyObject *_wrap_delete_CompositingFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7121 : PyObject *resultobj = 0;
7122 : struct _CompositingFilter *arg1 = (struct _CompositingFilter *) 0 ;
7123 0 : void *argp1 = 0 ;
7124 : int res1 = 0 ;
7125 0 : PyObject * obj0 = 0 ;
7126 :
7127 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_CompositingFilter",&obj0)) SWIG_fail;
7128 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN | 0 );
7129 0 : if (!SWIG_IsOK(res1)) {
7130 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CompositingFilter" "', argument " "1"" of type '" "struct _CompositingFilter *""'");
7131 : }
7132 0 : arg1 = (struct _CompositingFilter *)(argp1);
7133 : {
7134 0 : free((char *) arg1); {
7135 0 : errorObj *ms_error = msGetErrorObj();
7136 :
7137 0 : switch(ms_error->code) {
7138 : case MS_NOERR:
7139 : break;
7140 0 : case MS_NOTFOUND:
7141 0 : msResetErrorList();
7142 0 : break;
7143 : case -1:
7144 : break;
7145 0 : case MS_IOERR:
7146 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7147 0 : _raise_ms_exception();
7148 0 : msResetErrorList();
7149 0 : return NULL;
7150 : }
7151 : default:
7152 0 : _raise_ms_exception();
7153 0 : msResetErrorList();
7154 0 : return NULL;
7155 : }
7156 :
7157 : }
7158 : }
7159 : resultobj = SWIG_Py_Void();
7160 0 : return resultobj;
7161 0 : fail:
7162 : return NULL;
7163 : }
7164 :
7165 :
7166 1 : SWIGINTERN PyObject *CompositingFilter_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7167 : PyObject *obj;
7168 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
7169 1 : SWIG_TypeNewClientData(SWIGTYPE_p__CompositingFilter, SWIG_NewClientData(obj));
7170 1 : return SWIG_Py_Void();
7171 : }
7172 :
7173 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_comp_op_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 : PyObject *resultobj = 0;
7175 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7176 : CompositingOperation arg2 ;
7177 0 : void *argp1 = 0 ;
7178 : int res1 = 0 ;
7179 : int val2 ;
7180 : int ecode2 = 0 ;
7181 0 : PyObject * obj0 = 0 ;
7182 0 : PyObject * obj1 = 0 ;
7183 :
7184 0 : if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_comp_op_set",&obj0,&obj1)) SWIG_fail;
7185 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7186 0 : if (!SWIG_IsOK(res1)) {
7187 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_comp_op_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7188 : }
7189 0 : arg1 = (struct _LayerCompositer *)(argp1);
7190 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7191 0 : if (!SWIG_IsOK(ecode2)) {
7192 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerCompositer_comp_op_set" "', argument " "2"" of type '" "CompositingOperation""'");
7193 : }
7194 0 : arg2 = (CompositingOperation)(val2);
7195 0 : if (arg1) (arg1)->comp_op = arg2;
7196 : resultobj = SWIG_Py_Void();
7197 0 : return resultobj;
7198 0 : fail:
7199 : return NULL;
7200 : }
7201 :
7202 :
7203 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_comp_op_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7204 : PyObject *resultobj = 0;
7205 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7206 0 : void *argp1 = 0 ;
7207 : int res1 = 0 ;
7208 0 : PyObject * obj0 = 0 ;
7209 : CompositingOperation result;
7210 :
7211 0 : if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_comp_op_get",&obj0)) SWIG_fail;
7212 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7213 0 : if (!SWIG_IsOK(res1)) {
7214 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_comp_op_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7215 : }
7216 0 : arg1 = (struct _LayerCompositer *)(argp1);
7217 0 : result = (CompositingOperation) ((arg1)->comp_op);
7218 0 : resultobj = SWIG_From_int((int)(result));
7219 0 : return resultobj;
7220 0 : fail:
7221 : return NULL;
7222 : }
7223 :
7224 :
7225 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_opacity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7226 : PyObject *resultobj = 0;
7227 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7228 : int arg2 ;
7229 0 : void *argp1 = 0 ;
7230 : int res1 = 0 ;
7231 : int val2 ;
7232 : int ecode2 = 0 ;
7233 0 : PyObject * obj0 = 0 ;
7234 0 : PyObject * obj1 = 0 ;
7235 :
7236 0 : if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_opacity_set",&obj0,&obj1)) SWIG_fail;
7237 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7238 0 : if (!SWIG_IsOK(res1)) {
7239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_opacity_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7240 : }
7241 0 : arg1 = (struct _LayerCompositer *)(argp1);
7242 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7243 0 : if (!SWIG_IsOK(ecode2)) {
7244 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "LayerCompositer_opacity_set" "', argument " "2"" of type '" "int""'");
7245 : }
7246 : arg2 = (int)(val2);
7247 0 : if (arg1) (arg1)->opacity = arg2;
7248 : resultobj = SWIG_Py_Void();
7249 0 : return resultobj;
7250 0 : fail:
7251 : return NULL;
7252 : }
7253 :
7254 :
7255 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_opacity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7256 : PyObject *resultobj = 0;
7257 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7258 0 : void *argp1 = 0 ;
7259 : int res1 = 0 ;
7260 0 : PyObject * obj0 = 0 ;
7261 : int result;
7262 :
7263 0 : if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_opacity_get",&obj0)) SWIG_fail;
7264 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7265 0 : if (!SWIG_IsOK(res1)) {
7266 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_opacity_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7267 : }
7268 0 : arg1 = (struct _LayerCompositer *)(argp1);
7269 0 : result = (int) ((arg1)->opacity);
7270 : resultobj = SWIG_From_int((int)(result));
7271 0 : return resultobj;
7272 0 : fail:
7273 : return NULL;
7274 : }
7275 :
7276 :
7277 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_filter_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7278 : PyObject *resultobj = 0;
7279 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7280 : CompositingFilter *arg2 = (CompositingFilter *) 0 ;
7281 0 : void *argp1 = 0 ;
7282 : int res1 = 0 ;
7283 0 : void *argp2 = 0 ;
7284 : int res2 = 0 ;
7285 0 : PyObject * obj0 = 0 ;
7286 0 : PyObject * obj1 = 0 ;
7287 :
7288 0 : if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_filter_set",&obj0,&obj1)) SWIG_fail;
7289 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7290 0 : if (!SWIG_IsOK(res1)) {
7291 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_filter_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7292 : }
7293 0 : arg1 = (struct _LayerCompositer *)(argp1);
7294 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__CompositingFilter, SWIG_POINTER_DISOWN | 0 );
7295 0 : if (!SWIG_IsOK(res2)) {
7296 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayerCompositer_filter_set" "', argument " "2"" of type '" "CompositingFilter *""'");
7297 : }
7298 0 : arg2 = (CompositingFilter *)(argp2);
7299 0 : if (arg1) (arg1)->filter = arg2;
7300 : resultobj = SWIG_Py_Void();
7301 0 : return resultobj;
7302 0 : fail:
7303 : return NULL;
7304 : }
7305 :
7306 :
7307 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_filter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7308 : PyObject *resultobj = 0;
7309 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7310 0 : void *argp1 = 0 ;
7311 : int res1 = 0 ;
7312 0 : PyObject * obj0 = 0 ;
7313 : CompositingFilter *result = 0 ;
7314 :
7315 0 : if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_filter_get",&obj0)) SWIG_fail;
7316 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7317 0 : if (!SWIG_IsOK(res1)) {
7318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_filter_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7319 : }
7320 0 : arg1 = (struct _LayerCompositer *)(argp1);
7321 0 : result = (CompositingFilter *) ((arg1)->filter);
7322 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__CompositingFilter, 0 | 0 );
7323 0 : return resultobj;
7324 0 : fail:
7325 : return NULL;
7326 : }
7327 :
7328 :
7329 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_next_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7330 : PyObject *resultobj = 0;
7331 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7332 : struct _LayerCompositer *arg2 = (struct _LayerCompositer *) 0 ;
7333 0 : void *argp1 = 0 ;
7334 : int res1 = 0 ;
7335 0 : void *argp2 = 0 ;
7336 : int res2 = 0 ;
7337 0 : PyObject * obj0 = 0 ;
7338 0 : PyObject * obj1 = 0 ;
7339 :
7340 0 : if (!PyArg_ParseTuple(args,(char *)"OO:LayerCompositer_next_set",&obj0,&obj1)) SWIG_fail;
7341 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7342 0 : if (!SWIG_IsOK(res1)) {
7343 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_next_set" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7344 : }
7345 0 : arg1 = (struct _LayerCompositer *)(argp1);
7346 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN | 0 );
7347 0 : if (!SWIG_IsOK(res2)) {
7348 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayerCompositer_next_set" "', argument " "2"" of type '" "struct _LayerCompositer *""'");
7349 : }
7350 0 : arg2 = (struct _LayerCompositer *)(argp2);
7351 0 : if (arg1) (arg1)->next = arg2;
7352 : resultobj = SWIG_Py_Void();
7353 0 : return resultobj;
7354 0 : fail:
7355 : return NULL;
7356 : }
7357 :
7358 :
7359 0 : SWIGINTERN PyObject *_wrap_LayerCompositer_next_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7360 : PyObject *resultobj = 0;
7361 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7362 0 : void *argp1 = 0 ;
7363 : int res1 = 0 ;
7364 0 : PyObject * obj0 = 0 ;
7365 : struct _LayerCompositer *result = 0 ;
7366 :
7367 0 : if (!PyArg_ParseTuple(args,(char *)"O:LayerCompositer_next_get",&obj0)) SWIG_fail;
7368 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, 0 | 0 );
7369 0 : if (!SWIG_IsOK(res1)) {
7370 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayerCompositer_next_get" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7371 : }
7372 0 : arg1 = (struct _LayerCompositer *)(argp1);
7373 0 : result = (struct _LayerCompositer *) ((arg1)->next);
7374 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, 0 | 0 );
7375 0 : return resultobj;
7376 0 : fail:
7377 : return NULL;
7378 : }
7379 :
7380 :
7381 0 : SWIGINTERN PyObject *_wrap_new_LayerCompositer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7382 : PyObject *resultobj = 0;
7383 : struct _LayerCompositer *result = 0 ;
7384 :
7385 0 : if (!PyArg_ParseTuple(args,(char *)":new_LayerCompositer")) SWIG_fail;
7386 : {
7387 0 : result = (struct _LayerCompositer *)calloc(1, sizeof(struct _LayerCompositer)); {
7388 0 : errorObj *ms_error = msGetErrorObj();
7389 :
7390 0 : switch(ms_error->code) {
7391 : case MS_NOERR:
7392 : break;
7393 0 : case MS_NOTFOUND:
7394 0 : msResetErrorList();
7395 0 : break;
7396 : case -1:
7397 : break;
7398 0 : case MS_IOERR:
7399 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7400 0 : _raise_ms_exception();
7401 0 : msResetErrorList();
7402 0 : return NULL;
7403 : }
7404 : default:
7405 0 : _raise_ms_exception();
7406 0 : msResetErrorList();
7407 0 : return NULL;
7408 : }
7409 :
7410 : }
7411 : }
7412 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, SWIG_POINTER_NEW | 0 );
7413 0 : return resultobj;
7414 0 : fail:
7415 : return NULL;
7416 : }
7417 :
7418 :
7419 0 : SWIGINTERN PyObject *_wrap_delete_LayerCompositer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7420 : PyObject *resultobj = 0;
7421 : struct _LayerCompositer *arg1 = (struct _LayerCompositer *) 0 ;
7422 0 : void *argp1 = 0 ;
7423 : int res1 = 0 ;
7424 0 : PyObject * obj0 = 0 ;
7425 :
7426 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_LayerCompositer",&obj0)) SWIG_fail;
7427 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN | 0 );
7428 0 : if (!SWIG_IsOK(res1)) {
7429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayerCompositer" "', argument " "1"" of type '" "struct _LayerCompositer *""'");
7430 : }
7431 0 : arg1 = (struct _LayerCompositer *)(argp1);
7432 : {
7433 0 : free((char *) arg1); {
7434 0 : errorObj *ms_error = msGetErrorObj();
7435 :
7436 0 : switch(ms_error->code) {
7437 : case MS_NOERR:
7438 : break;
7439 0 : case MS_NOTFOUND:
7440 0 : msResetErrorList();
7441 0 : break;
7442 : case -1:
7443 : break;
7444 0 : case MS_IOERR:
7445 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7446 0 : _raise_ms_exception();
7447 0 : msResetErrorList();
7448 0 : return NULL;
7449 : }
7450 : default:
7451 0 : _raise_ms_exception();
7452 0 : msResetErrorList();
7453 0 : return NULL;
7454 : }
7455 :
7456 : }
7457 : }
7458 : resultobj = SWIG_Py_Void();
7459 0 : return resultobj;
7460 0 : fail:
7461 : return NULL;
7462 : }
7463 :
7464 :
7465 1 : SWIGINTERN PyObject *LayerCompositer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7466 : PyObject *obj;
7467 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
7468 1 : SWIG_TypeNewClientData(SWIGTYPE_p__LayerCompositer, SWIG_NewClientData(obj));
7469 1 : return SWIG_Py_Void();
7470 : }
7471 :
7472 1 : SWIGINTERN PyObject *_wrap_fontSetObj_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7473 : PyObject *resultobj = 0;
7474 : fontSetObj *arg1 = (fontSetObj *) 0 ;
7475 1 : void *argp1 = 0 ;
7476 : int res1 = 0 ;
7477 1 : PyObject * obj0 = 0 ;
7478 : char *result = 0 ;
7479 :
7480 1 : if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_filename_get",&obj0)) SWIG_fail;
7481 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 | 0 );
7482 1 : if (!SWIG_IsOK(res1)) {
7483 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_filename_get" "', argument " "1"" of type '" "fontSetObj *""'");
7484 : }
7485 1 : arg1 = (fontSetObj *)(argp1);
7486 1 : result = (char *) ((arg1)->filename);
7487 1 : resultobj = SWIG_FromCharPtr((const char *)result);
7488 1 : return resultobj;
7489 0 : fail:
7490 : return NULL;
7491 : }
7492 :
7493 :
7494 1 : SWIGINTERN PyObject *_wrap_fontSetObj_numfonts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7495 : PyObject *resultobj = 0;
7496 : fontSetObj *arg1 = (fontSetObj *) 0 ;
7497 1 : void *argp1 = 0 ;
7498 : int res1 = 0 ;
7499 1 : PyObject * obj0 = 0 ;
7500 : int result;
7501 :
7502 1 : if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_numfonts_get",&obj0)) SWIG_fail;
7503 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 | 0 );
7504 1 : if (!SWIG_IsOK(res1)) {
7505 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_numfonts_get" "', argument " "1"" of type '" "fontSetObj *""'");
7506 : }
7507 1 : arg1 = (fontSetObj *)(argp1);
7508 1 : result = (int) ((arg1)->numfonts);
7509 : resultobj = SWIG_From_int((int)(result));
7510 1 : return resultobj;
7511 0 : fail:
7512 : return NULL;
7513 : }
7514 :
7515 :
7516 1 : SWIGINTERN PyObject *_wrap_fontSetObj_fonts_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7517 : PyObject *resultobj = 0;
7518 : fontSetObj *arg1 = (fontSetObj *) 0 ;
7519 1 : void *argp1 = 0 ;
7520 : int res1 = 0 ;
7521 1 : PyObject * obj0 = 0 ;
7522 : hashTableObj *result = 0 ;
7523 :
7524 1 : if (!PyArg_ParseTuple(args,(char *)"O:fontSetObj_fonts_get",&obj0)) SWIG_fail;
7525 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, 0 | 0 );
7526 1 : if (!SWIG_IsOK(res1)) {
7527 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "fontSetObj_fonts_get" "', argument " "1"" of type '" "fontSetObj *""'");
7528 : }
7529 1 : arg1 = (fontSetObj *)(argp1);
7530 1 : result = (hashTableObj *)& ((arg1)->fonts);
7531 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
7532 1 : return resultobj;
7533 0 : fail:
7534 : return NULL;
7535 : }
7536 :
7537 :
7538 0 : SWIGINTERN PyObject *_wrap_new_fontSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7539 : PyObject *resultobj = 0;
7540 : fontSetObj *result = 0 ;
7541 :
7542 0 : if (!PyArg_ParseTuple(args,(char *)":new_fontSetObj")) SWIG_fail;
7543 : {
7544 0 : result = (fontSetObj *)calloc(1, sizeof(fontSetObj)); {
7545 0 : errorObj *ms_error = msGetErrorObj();
7546 :
7547 0 : switch(ms_error->code) {
7548 : case MS_NOERR:
7549 : break;
7550 0 : case MS_NOTFOUND:
7551 0 : msResetErrorList();
7552 0 : break;
7553 : case -1:
7554 : break;
7555 0 : case MS_IOERR:
7556 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7557 0 : _raise_ms_exception();
7558 0 : msResetErrorList();
7559 0 : return NULL;
7560 : }
7561 : default:
7562 0 : _raise_ms_exception();
7563 0 : msResetErrorList();
7564 0 : return NULL;
7565 : }
7566 :
7567 : }
7568 : }
7569 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fontSetObj, SWIG_POINTER_NEW | 0 );
7570 0 : return resultobj;
7571 0 : fail:
7572 : return NULL;
7573 : }
7574 :
7575 :
7576 0 : SWIGINTERN PyObject *_wrap_delete_fontSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7577 : PyObject *resultobj = 0;
7578 : fontSetObj *arg1 = (fontSetObj *) 0 ;
7579 0 : void *argp1 = 0 ;
7580 : int res1 = 0 ;
7581 0 : PyObject * obj0 = 0 ;
7582 :
7583 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_fontSetObj",&obj0)) SWIG_fail;
7584 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_fontSetObj, SWIG_POINTER_DISOWN | 0 );
7585 0 : if (!SWIG_IsOK(res1)) {
7586 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_fontSetObj" "', argument " "1"" of type '" "fontSetObj *""'");
7587 : }
7588 0 : arg1 = (fontSetObj *)(argp1);
7589 : {
7590 0 : free((char *) arg1); {
7591 0 : errorObj *ms_error = msGetErrorObj();
7592 :
7593 0 : switch(ms_error->code) {
7594 : case MS_NOERR:
7595 : break;
7596 0 : case MS_NOTFOUND:
7597 0 : msResetErrorList();
7598 0 : break;
7599 : case -1:
7600 : break;
7601 0 : case MS_IOERR:
7602 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7603 0 : _raise_ms_exception();
7604 0 : msResetErrorList();
7605 0 : return NULL;
7606 : }
7607 : default:
7608 0 : _raise_ms_exception();
7609 0 : msResetErrorList();
7610 0 : return NULL;
7611 : }
7612 :
7613 : }
7614 : }
7615 : resultobj = SWIG_Py_Void();
7616 0 : return resultobj;
7617 0 : fail:
7618 : return NULL;
7619 : }
7620 :
7621 :
7622 1 : SWIGINTERN PyObject *fontSetObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 : PyObject *obj;
7624 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
7625 1 : SWIG_TypeNewClientData(SWIGTYPE_p_fontSetObj, SWIG_NewClientData(obj));
7626 1 : return SWIG_Py_Void();
7627 : }
7628 :
7629 0 : SWIGINTERN PyObject *_wrap_clusterObj_maxdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7630 : PyObject *resultobj = 0;
7631 : clusterObj *arg1 = (clusterObj *) 0 ;
7632 : double arg2 ;
7633 0 : void *argp1 = 0 ;
7634 : int res1 = 0 ;
7635 : double val2 ;
7636 : int ecode2 = 0 ;
7637 0 : PyObject * obj0 = 0 ;
7638 0 : PyObject * obj1 = 0 ;
7639 :
7640 0 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_maxdistance_set",&obj0,&obj1)) SWIG_fail;
7641 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7642 0 : if (!SWIG_IsOK(res1)) {
7643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_maxdistance_set" "', argument " "1"" of type '" "clusterObj *""'");
7644 : }
7645 0 : arg1 = (clusterObj *)(argp1);
7646 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7647 0 : if (!SWIG_IsOK(ecode2)) {
7648 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clusterObj_maxdistance_set" "', argument " "2"" of type '" "double""'");
7649 : }
7650 0 : arg2 = (double)(val2);
7651 0 : if (arg1) (arg1)->maxdistance = arg2;
7652 : resultobj = SWIG_Py_Void();
7653 0 : return resultobj;
7654 0 : fail:
7655 : return NULL;
7656 : }
7657 :
7658 :
7659 1 : SWIGINTERN PyObject *_wrap_clusterObj_maxdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7660 : PyObject *resultobj = 0;
7661 : clusterObj *arg1 = (clusterObj *) 0 ;
7662 1 : void *argp1 = 0 ;
7663 : int res1 = 0 ;
7664 1 : PyObject * obj0 = 0 ;
7665 : double result;
7666 :
7667 1 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_maxdistance_get",&obj0)) SWIG_fail;
7668 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7669 1 : if (!SWIG_IsOK(res1)) {
7670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_maxdistance_get" "', argument " "1"" of type '" "clusterObj *""'");
7671 : }
7672 1 : arg1 = (clusterObj *)(argp1);
7673 1 : result = (double) ((arg1)->maxdistance);
7674 1 : resultobj = SWIG_From_double((double)(result));
7675 1 : return resultobj;
7676 0 : fail:
7677 : return NULL;
7678 : }
7679 :
7680 :
7681 0 : SWIGINTERN PyObject *_wrap_clusterObj_buffer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7682 : PyObject *resultobj = 0;
7683 : clusterObj *arg1 = (clusterObj *) 0 ;
7684 : double arg2 ;
7685 0 : void *argp1 = 0 ;
7686 : int res1 = 0 ;
7687 : double val2 ;
7688 : int ecode2 = 0 ;
7689 0 : PyObject * obj0 = 0 ;
7690 0 : PyObject * obj1 = 0 ;
7691 :
7692 0 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_buffer_set",&obj0,&obj1)) SWIG_fail;
7693 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7694 0 : if (!SWIG_IsOK(res1)) {
7695 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_buffer_set" "', argument " "1"" of type '" "clusterObj *""'");
7696 : }
7697 0 : arg1 = (clusterObj *)(argp1);
7698 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
7699 0 : if (!SWIG_IsOK(ecode2)) {
7700 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "clusterObj_buffer_set" "', argument " "2"" of type '" "double""'");
7701 : }
7702 0 : arg2 = (double)(val2);
7703 0 : if (arg1) (arg1)->buffer = arg2;
7704 : resultobj = SWIG_Py_Void();
7705 0 : return resultobj;
7706 0 : fail:
7707 : return NULL;
7708 : }
7709 :
7710 :
7711 0 : SWIGINTERN PyObject *_wrap_clusterObj_buffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7712 : PyObject *resultobj = 0;
7713 : clusterObj *arg1 = (clusterObj *) 0 ;
7714 0 : void *argp1 = 0 ;
7715 : int res1 = 0 ;
7716 0 : PyObject * obj0 = 0 ;
7717 : double result;
7718 :
7719 0 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_buffer_get",&obj0)) SWIG_fail;
7720 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7721 0 : if (!SWIG_IsOK(res1)) {
7722 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_buffer_get" "', argument " "1"" of type '" "clusterObj *""'");
7723 : }
7724 0 : arg1 = (clusterObj *)(argp1);
7725 0 : result = (double) ((arg1)->buffer);
7726 0 : resultobj = SWIG_From_double((double)(result));
7727 0 : return resultobj;
7728 0 : fail:
7729 : return NULL;
7730 : }
7731 :
7732 :
7733 0 : SWIGINTERN PyObject *_wrap_clusterObj_region_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 : PyObject *resultobj = 0;
7735 : clusterObj *arg1 = (clusterObj *) 0 ;
7736 : char *arg2 = (char *) 0 ;
7737 0 : void *argp1 = 0 ;
7738 : int res1 = 0 ;
7739 : int res2 ;
7740 0 : char *buf2 = 0 ;
7741 0 : int alloc2 = 0 ;
7742 0 : PyObject * obj0 = 0 ;
7743 0 : PyObject * obj1 = 0 ;
7744 :
7745 0 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_region_set",&obj0,&obj1)) SWIG_fail;
7746 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7747 0 : if (!SWIG_IsOK(res1)) {
7748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_region_set" "', argument " "1"" of type '" "clusterObj *""'");
7749 : }
7750 0 : arg1 = (clusterObj *)(argp1);
7751 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7752 0 : if (!SWIG_IsOK(res2)) {
7753 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_region_set" "', argument " "2"" of type '" "char *""'");
7754 : }
7755 0 : arg2 = (char *)(buf2);
7756 : {
7757 0 : if (arg1->region) free((char*)arg1->region);
7758 0 : if (arg2) {
7759 0 : arg1->region = (char *) malloc(strlen(arg2)+1);
7760 : strcpy((char*)arg1->region,arg2);
7761 : } else {
7762 0 : arg1->region = 0;
7763 : }
7764 : }
7765 : resultobj = SWIG_Py_Void();
7766 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7767 : return resultobj;
7768 0 : fail:
7769 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7770 : return NULL;
7771 : }
7772 :
7773 :
7774 1 : SWIGINTERN PyObject *_wrap_clusterObj_region_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7775 : PyObject *resultobj = 0;
7776 : clusterObj *arg1 = (clusterObj *) 0 ;
7777 1 : void *argp1 = 0 ;
7778 : int res1 = 0 ;
7779 1 : PyObject * obj0 = 0 ;
7780 : char *result = 0 ;
7781 :
7782 1 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_region_get",&obj0)) SWIG_fail;
7783 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7784 1 : if (!SWIG_IsOK(res1)) {
7785 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_region_get" "', argument " "1"" of type '" "clusterObj *""'");
7786 : }
7787 1 : arg1 = (clusterObj *)(argp1);
7788 1 : result = (char *) ((arg1)->region);
7789 1 : resultobj = SWIG_FromCharPtr((const char *)result);
7790 1 : return resultobj;
7791 0 : fail:
7792 : return NULL;
7793 : }
7794 :
7795 :
7796 1 : SWIGINTERN PyObject *_wrap_clusterObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 : PyObject *resultobj = 0;
7798 : clusterObj *arg1 = (clusterObj *) 0 ;
7799 : char *arg2 = (char *) 0 ;
7800 1 : void *argp1 = 0 ;
7801 : int res1 = 0 ;
7802 : int res2 ;
7803 1 : char *buf2 = 0 ;
7804 1 : int alloc2 = 0 ;
7805 1 : PyObject * obj0 = 0 ;
7806 1 : PyObject * obj1 = 0 ;
7807 : int result;
7808 :
7809 1 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_updateFromString",&obj0,&obj1)) SWIG_fail;
7810 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7811 1 : if (!SWIG_IsOK(res1)) {
7812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_updateFromString" "', argument " "1"" of type '" "clusterObj *""'");
7813 : }
7814 1 : arg1 = (clusterObj *)(argp1);
7815 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7816 1 : if (!SWIG_IsOK(res2)) {
7817 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_updateFromString" "', argument " "2"" of type '" "char *""'");
7818 : }
7819 1 : arg2 = (char *)(buf2);
7820 : {
7821 : result = (int)clusterObj_updateFromString(arg1,arg2); {
7822 1 : errorObj *ms_error = msGetErrorObj();
7823 :
7824 1 : switch(ms_error->code) {
7825 : case MS_NOERR:
7826 : break;
7827 0 : case MS_NOTFOUND:
7828 0 : msResetErrorList();
7829 0 : break;
7830 : case -1:
7831 : break;
7832 0 : case MS_IOERR:
7833 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7834 0 : _raise_ms_exception();
7835 0 : msResetErrorList();
7836 0 : return NULL;
7837 : }
7838 : default:
7839 0 : _raise_ms_exception();
7840 0 : msResetErrorList();
7841 0 : return NULL;
7842 : }
7843 :
7844 : }
7845 : }
7846 : resultobj = SWIG_From_int((int)(result));
7847 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7848 : return resultobj;
7849 0 : fail:
7850 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7851 : return NULL;
7852 : }
7853 :
7854 :
7855 1 : SWIGINTERN PyObject *_wrap_clusterObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7856 : PyObject *resultobj = 0;
7857 : clusterObj *arg1 = (clusterObj *) 0 ;
7858 1 : void *argp1 = 0 ;
7859 : int res1 = 0 ;
7860 1 : PyObject * obj0 = 0 ;
7861 : char *result = 0 ;
7862 :
7863 1 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_convertToString",&obj0)) SWIG_fail;
7864 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7865 1 : if (!SWIG_IsOK(res1)) {
7866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_convertToString" "', argument " "1"" of type '" "clusterObj *""'");
7867 : }
7868 1 : arg1 = (clusterObj *)(argp1);
7869 : {
7870 : result = (char *)clusterObj_convertToString(arg1); {
7871 1 : errorObj *ms_error = msGetErrorObj();
7872 :
7873 1 : switch(ms_error->code) {
7874 : case MS_NOERR:
7875 : break;
7876 0 : case MS_NOTFOUND:
7877 0 : msResetErrorList();
7878 0 : break;
7879 : case -1:
7880 : break;
7881 0 : case MS_IOERR:
7882 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7883 0 : _raise_ms_exception();
7884 0 : msResetErrorList();
7885 0 : return NULL;
7886 : }
7887 : default:
7888 0 : _raise_ms_exception();
7889 0 : msResetErrorList();
7890 0 : return NULL;
7891 : }
7892 :
7893 : }
7894 : }
7895 1 : resultobj = SWIG_FromCharPtr((const char *)result);
7896 1 : free((char*)result);
7897 1 : return resultobj;
7898 0 : fail:
7899 : return NULL;
7900 : }
7901 :
7902 :
7903 1 : SWIGINTERN PyObject *_wrap_clusterObj_setGroup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7904 : PyObject *resultobj = 0;
7905 : clusterObj *arg1 = (clusterObj *) 0 ;
7906 : char *arg2 = (char *) 0 ;
7907 1 : void *argp1 = 0 ;
7908 : int res1 = 0 ;
7909 : int res2 ;
7910 1 : char *buf2 = 0 ;
7911 1 : int alloc2 = 0 ;
7912 1 : PyObject * obj0 = 0 ;
7913 1 : PyObject * obj1 = 0 ;
7914 : int result;
7915 :
7916 1 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_setGroup",&obj0,&obj1)) SWIG_fail;
7917 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7918 1 : if (!SWIG_IsOK(res1)) {
7919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_setGroup" "', argument " "1"" of type '" "clusterObj *""'");
7920 : }
7921 1 : arg1 = (clusterObj *)(argp1);
7922 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7923 1 : if (!SWIG_IsOK(res2)) {
7924 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_setGroup" "', argument " "2"" of type '" "char *""'");
7925 : }
7926 1 : arg2 = (char *)(buf2);
7927 : {
7928 1 : result = (int)clusterObj_setGroup(arg1,arg2); {
7929 1 : errorObj *ms_error = msGetErrorObj();
7930 :
7931 1 : switch(ms_error->code) {
7932 : case MS_NOERR:
7933 : break;
7934 0 : case MS_NOTFOUND:
7935 0 : msResetErrorList();
7936 0 : break;
7937 : case -1:
7938 : break;
7939 0 : case MS_IOERR:
7940 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7941 0 : _raise_ms_exception();
7942 0 : msResetErrorList();
7943 0 : return NULL;
7944 : }
7945 : default:
7946 0 : _raise_ms_exception();
7947 0 : msResetErrorList();
7948 0 : return NULL;
7949 : }
7950 :
7951 : }
7952 : }
7953 : resultobj = SWIG_From_int((int)(result));
7954 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7955 : return resultobj;
7956 0 : fail:
7957 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7958 : return NULL;
7959 : }
7960 :
7961 :
7962 1 : SWIGINTERN PyObject *_wrap_clusterObj_getGroupString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7963 : PyObject *resultobj = 0;
7964 : clusterObj *arg1 = (clusterObj *) 0 ;
7965 1 : void *argp1 = 0 ;
7966 : int res1 = 0 ;
7967 1 : PyObject * obj0 = 0 ;
7968 : char *result = 0 ;
7969 :
7970 1 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_getGroupString",&obj0)) SWIG_fail;
7971 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
7972 1 : if (!SWIG_IsOK(res1)) {
7973 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_getGroupString" "', argument " "1"" of type '" "clusterObj *""'");
7974 : }
7975 1 : arg1 = (clusterObj *)(argp1);
7976 : {
7977 : result = (char *)clusterObj_getGroupString(arg1); {
7978 1 : errorObj *ms_error = msGetErrorObj();
7979 :
7980 1 : switch(ms_error->code) {
7981 : case MS_NOERR:
7982 : break;
7983 0 : case MS_NOTFOUND:
7984 0 : msResetErrorList();
7985 0 : break;
7986 : case -1:
7987 : break;
7988 0 : case MS_IOERR:
7989 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
7990 0 : _raise_ms_exception();
7991 0 : msResetErrorList();
7992 0 : return NULL;
7993 : }
7994 : default:
7995 0 : _raise_ms_exception();
7996 0 : msResetErrorList();
7997 0 : return NULL;
7998 : }
7999 :
8000 : }
8001 : }
8002 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8003 1 : free((char*)result);
8004 1 : return resultobj;
8005 0 : fail:
8006 : return NULL;
8007 : }
8008 :
8009 :
8010 1 : SWIGINTERN PyObject *_wrap_clusterObj_setFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8011 : PyObject *resultobj = 0;
8012 : clusterObj *arg1 = (clusterObj *) 0 ;
8013 : char *arg2 = (char *) 0 ;
8014 1 : void *argp1 = 0 ;
8015 : int res1 = 0 ;
8016 : int res2 ;
8017 1 : char *buf2 = 0 ;
8018 1 : int alloc2 = 0 ;
8019 1 : PyObject * obj0 = 0 ;
8020 1 : PyObject * obj1 = 0 ;
8021 : int result;
8022 :
8023 1 : if (!PyArg_ParseTuple(args,(char *)"OO:clusterObj_setFilter",&obj0,&obj1)) SWIG_fail;
8024 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
8025 1 : if (!SWIG_IsOK(res1)) {
8026 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_setFilter" "', argument " "1"" of type '" "clusterObj *""'");
8027 : }
8028 1 : arg1 = (clusterObj *)(argp1);
8029 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8030 1 : if (!SWIG_IsOK(res2)) {
8031 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "clusterObj_setFilter" "', argument " "2"" of type '" "char *""'");
8032 : }
8033 1 : arg2 = (char *)(buf2);
8034 : {
8035 1 : result = (int)clusterObj_setFilter(arg1,arg2); {
8036 1 : errorObj *ms_error = msGetErrorObj();
8037 :
8038 1 : switch(ms_error->code) {
8039 : case MS_NOERR:
8040 : break;
8041 0 : case MS_NOTFOUND:
8042 0 : msResetErrorList();
8043 0 : break;
8044 : case -1:
8045 : break;
8046 0 : case MS_IOERR:
8047 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8048 0 : _raise_ms_exception();
8049 0 : msResetErrorList();
8050 0 : return NULL;
8051 : }
8052 : default:
8053 0 : _raise_ms_exception();
8054 0 : msResetErrorList();
8055 0 : return NULL;
8056 : }
8057 :
8058 : }
8059 : }
8060 : resultobj = SWIG_From_int((int)(result));
8061 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8062 : return resultobj;
8063 0 : fail:
8064 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8065 : return NULL;
8066 : }
8067 :
8068 :
8069 1 : SWIGINTERN PyObject *_wrap_clusterObj_getFilterString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8070 : PyObject *resultobj = 0;
8071 : clusterObj *arg1 = (clusterObj *) 0 ;
8072 1 : void *argp1 = 0 ;
8073 : int res1 = 0 ;
8074 1 : PyObject * obj0 = 0 ;
8075 : char *result = 0 ;
8076 :
8077 1 : if (!PyArg_ParseTuple(args,(char *)"O:clusterObj_getFilterString",&obj0)) SWIG_fail;
8078 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, 0 | 0 );
8079 1 : if (!SWIG_IsOK(res1)) {
8080 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "clusterObj_getFilterString" "', argument " "1"" of type '" "clusterObj *""'");
8081 : }
8082 1 : arg1 = (clusterObj *)(argp1);
8083 : {
8084 : result = (char *)clusterObj_getFilterString(arg1); {
8085 1 : errorObj *ms_error = msGetErrorObj();
8086 :
8087 1 : switch(ms_error->code) {
8088 : case MS_NOERR:
8089 : break;
8090 0 : case MS_NOTFOUND:
8091 0 : msResetErrorList();
8092 0 : break;
8093 : case -1:
8094 : break;
8095 0 : case MS_IOERR:
8096 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8097 0 : _raise_ms_exception();
8098 0 : msResetErrorList();
8099 0 : return NULL;
8100 : }
8101 : default:
8102 0 : _raise_ms_exception();
8103 0 : msResetErrorList();
8104 0 : return NULL;
8105 : }
8106 :
8107 : }
8108 : }
8109 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8110 1 : free((char*)result);
8111 1 : return resultobj;
8112 0 : fail:
8113 : return NULL;
8114 : }
8115 :
8116 :
8117 1 : SWIGINTERN PyObject *_wrap_new_clusterObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8118 : PyObject *resultobj = 0;
8119 : clusterObj *result = 0 ;
8120 :
8121 1 : if (!PyArg_ParseTuple(args,(char *)":new_clusterObj")) SWIG_fail;
8122 : {
8123 1 : result = (clusterObj *)calloc(1, sizeof(clusterObj)); {
8124 1 : errorObj *ms_error = msGetErrorObj();
8125 :
8126 1 : switch(ms_error->code) {
8127 : case MS_NOERR:
8128 : break;
8129 0 : case MS_NOTFOUND:
8130 0 : msResetErrorList();
8131 0 : break;
8132 : case -1:
8133 : break;
8134 0 : case MS_IOERR:
8135 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8136 0 : _raise_ms_exception();
8137 0 : msResetErrorList();
8138 0 : return NULL;
8139 : }
8140 : default:
8141 0 : _raise_ms_exception();
8142 0 : msResetErrorList();
8143 0 : return NULL;
8144 : }
8145 :
8146 : }
8147 : }
8148 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_clusterObj, SWIG_POINTER_NEW | 0 );
8149 1 : return resultobj;
8150 1 : fail:
8151 : return NULL;
8152 : }
8153 :
8154 :
8155 1 : SWIGINTERN PyObject *_wrap_delete_clusterObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8156 : PyObject *resultobj = 0;
8157 : clusterObj *arg1 = (clusterObj *) 0 ;
8158 1 : void *argp1 = 0 ;
8159 : int res1 = 0 ;
8160 1 : PyObject * obj0 = 0 ;
8161 :
8162 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_clusterObj",&obj0)) SWIG_fail;
8163 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_clusterObj, SWIG_POINTER_DISOWN | 0 );
8164 1 : if (!SWIG_IsOK(res1)) {
8165 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_clusterObj" "', argument " "1"" of type '" "clusterObj *""'");
8166 : }
8167 1 : arg1 = (clusterObj *)(argp1);
8168 : {
8169 1 : free((char *) arg1); {
8170 1 : errorObj *ms_error = msGetErrorObj();
8171 :
8172 1 : switch(ms_error->code) {
8173 : case MS_NOERR:
8174 : break;
8175 0 : case MS_NOTFOUND:
8176 0 : msResetErrorList();
8177 0 : break;
8178 : case -1:
8179 : break;
8180 0 : case MS_IOERR:
8181 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8182 0 : _raise_ms_exception();
8183 0 : msResetErrorList();
8184 0 : return NULL;
8185 : }
8186 : default:
8187 0 : _raise_ms_exception();
8188 0 : msResetErrorList();
8189 0 : return NULL;
8190 : }
8191 :
8192 : }
8193 : }
8194 : resultobj = SWIG_Py_Void();
8195 1 : return resultobj;
8196 0 : fail:
8197 : return NULL;
8198 : }
8199 :
8200 :
8201 1 : SWIGINTERN PyObject *clusterObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8202 : PyObject *obj;
8203 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
8204 1 : SWIG_TypeNewClientData(SWIGTYPE_p_clusterObj, SWIG_NewClientData(obj));
8205 1 : return SWIG_Py_Void();
8206 : }
8207 :
8208 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_numformatoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8209 : PyObject *resultobj = 0;
8210 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8211 0 : void *argp1 = 0 ;
8212 : int res1 = 0 ;
8213 0 : PyObject * obj0 = 0 ;
8214 : int result;
8215 :
8216 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_numformatoptions_get",&obj0)) SWIG_fail;
8217 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8218 0 : if (!SWIG_IsOK(res1)) {
8219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_numformatoptions_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8220 : }
8221 0 : arg1 = (outputFormatObj *)(argp1);
8222 0 : result = (int) ((arg1)->numformatoptions);
8223 : resultobj = SWIG_From_int((int)(result));
8224 0 : return resultobj;
8225 0 : fail:
8226 : return NULL;
8227 : }
8228 :
8229 :
8230 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8231 : PyObject *resultobj = 0;
8232 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8233 : char *arg2 = (char *) 0 ;
8234 0 : void *argp1 = 0 ;
8235 : int res1 = 0 ;
8236 : int res2 ;
8237 0 : char *buf2 = 0 ;
8238 0 : int alloc2 = 0 ;
8239 0 : PyObject * obj0 = 0 ;
8240 0 : PyObject * obj1 = 0 ;
8241 :
8242 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_name_set",&obj0,&obj1)) SWIG_fail;
8243 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8244 0 : if (!SWIG_IsOK(res1)) {
8245 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_name_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8246 : }
8247 0 : arg1 = (outputFormatObj *)(argp1);
8248 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8249 0 : if (!SWIG_IsOK(res2)) {
8250 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_name_set" "', argument " "2"" of type '" "char *""'");
8251 : }
8252 0 : arg2 = (char *)(buf2);
8253 : {
8254 0 : if (arg1->name) free((char*)arg1->name);
8255 0 : if (arg2) {
8256 0 : arg1->name = (char *) malloc(strlen(arg2)+1);
8257 : strcpy((char*)arg1->name,arg2);
8258 : } else {
8259 0 : arg1->name = 0;
8260 : }
8261 : }
8262 : resultobj = SWIG_Py_Void();
8263 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8264 : return resultobj;
8265 0 : fail:
8266 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8267 : return NULL;
8268 : }
8269 :
8270 :
8271 1 : SWIGINTERN PyObject *_wrap_outputFormatObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8272 : PyObject *resultobj = 0;
8273 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8274 1 : void *argp1 = 0 ;
8275 : int res1 = 0 ;
8276 1 : PyObject * obj0 = 0 ;
8277 : char *result = 0 ;
8278 :
8279 1 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_name_get",&obj0)) SWIG_fail;
8280 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8281 1 : if (!SWIG_IsOK(res1)) {
8282 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_name_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8283 : }
8284 1 : arg1 = (outputFormatObj *)(argp1);
8285 1 : result = (char *) ((arg1)->name);
8286 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8287 1 : return resultobj;
8288 0 : fail:
8289 : return NULL;
8290 : }
8291 :
8292 :
8293 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_mimetype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8294 : PyObject *resultobj = 0;
8295 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8296 : char *arg2 = (char *) 0 ;
8297 0 : void *argp1 = 0 ;
8298 : int res1 = 0 ;
8299 : int res2 ;
8300 0 : char *buf2 = 0 ;
8301 0 : int alloc2 = 0 ;
8302 0 : PyObject * obj0 = 0 ;
8303 0 : PyObject * obj1 = 0 ;
8304 :
8305 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_mimetype_set",&obj0,&obj1)) SWIG_fail;
8306 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8307 0 : if (!SWIG_IsOK(res1)) {
8308 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_mimetype_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8309 : }
8310 0 : arg1 = (outputFormatObj *)(argp1);
8311 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8312 0 : if (!SWIG_IsOK(res2)) {
8313 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_mimetype_set" "', argument " "2"" of type '" "char *""'");
8314 : }
8315 0 : arg2 = (char *)(buf2);
8316 : {
8317 0 : if (arg1->mimetype) free((char*)arg1->mimetype);
8318 0 : if (arg2) {
8319 0 : arg1->mimetype = (char *) malloc(strlen(arg2)+1);
8320 : strcpy((char*)arg1->mimetype,arg2);
8321 : } else {
8322 0 : arg1->mimetype = 0;
8323 : }
8324 : }
8325 : resultobj = SWIG_Py_Void();
8326 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8327 : return resultobj;
8328 0 : fail:
8329 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8330 : return NULL;
8331 : }
8332 :
8333 :
8334 1 : SWIGINTERN PyObject *_wrap_outputFormatObj_mimetype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8335 : PyObject *resultobj = 0;
8336 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8337 1 : void *argp1 = 0 ;
8338 : int res1 = 0 ;
8339 1 : PyObject * obj0 = 0 ;
8340 : char *result = 0 ;
8341 :
8342 1 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_mimetype_get",&obj0)) SWIG_fail;
8343 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8344 1 : if (!SWIG_IsOK(res1)) {
8345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_mimetype_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8346 : }
8347 1 : arg1 = (outputFormatObj *)(argp1);
8348 1 : result = (char *) ((arg1)->mimetype);
8349 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8350 1 : return resultobj;
8351 0 : fail:
8352 : return NULL;
8353 : }
8354 :
8355 :
8356 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_driver_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8357 : PyObject *resultobj = 0;
8358 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8359 : char *arg2 = (char *) 0 ;
8360 0 : void *argp1 = 0 ;
8361 : int res1 = 0 ;
8362 : int res2 ;
8363 0 : char *buf2 = 0 ;
8364 0 : int alloc2 = 0 ;
8365 0 : PyObject * obj0 = 0 ;
8366 0 : PyObject * obj1 = 0 ;
8367 :
8368 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_driver_set",&obj0,&obj1)) SWIG_fail;
8369 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8370 0 : if (!SWIG_IsOK(res1)) {
8371 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_driver_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8372 : }
8373 0 : arg1 = (outputFormatObj *)(argp1);
8374 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8375 0 : if (!SWIG_IsOK(res2)) {
8376 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_driver_set" "', argument " "2"" of type '" "char *""'");
8377 : }
8378 0 : arg2 = (char *)(buf2);
8379 : {
8380 0 : if (arg1->driver) free((char*)arg1->driver);
8381 0 : if (arg2) {
8382 0 : arg1->driver = (char *) malloc(strlen(arg2)+1);
8383 : strcpy((char*)arg1->driver,arg2);
8384 : } else {
8385 0 : arg1->driver = 0;
8386 : }
8387 : }
8388 : resultobj = SWIG_Py_Void();
8389 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8390 : return resultobj;
8391 0 : fail:
8392 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8393 : return NULL;
8394 : }
8395 :
8396 :
8397 1 : SWIGINTERN PyObject *_wrap_outputFormatObj_driver_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8398 : PyObject *resultobj = 0;
8399 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8400 1 : void *argp1 = 0 ;
8401 : int res1 = 0 ;
8402 1 : PyObject * obj0 = 0 ;
8403 : char *result = 0 ;
8404 :
8405 1 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_driver_get",&obj0)) SWIG_fail;
8406 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8407 1 : if (!SWIG_IsOK(res1)) {
8408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_driver_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8409 : }
8410 1 : arg1 = (outputFormatObj *)(argp1);
8411 1 : result = (char *) ((arg1)->driver);
8412 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8413 1 : return resultobj;
8414 0 : fail:
8415 : return NULL;
8416 : }
8417 :
8418 :
8419 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_extension_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8420 : PyObject *resultobj = 0;
8421 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8422 : char *arg2 = (char *) 0 ;
8423 0 : void *argp1 = 0 ;
8424 : int res1 = 0 ;
8425 : int res2 ;
8426 0 : char *buf2 = 0 ;
8427 0 : int alloc2 = 0 ;
8428 0 : PyObject * obj0 = 0 ;
8429 0 : PyObject * obj1 = 0 ;
8430 :
8431 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_extension_set",&obj0,&obj1)) SWIG_fail;
8432 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8433 0 : if (!SWIG_IsOK(res1)) {
8434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_extension_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8435 : }
8436 0 : arg1 = (outputFormatObj *)(argp1);
8437 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8438 0 : if (!SWIG_IsOK(res2)) {
8439 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_extension_set" "', argument " "2"" of type '" "char *""'");
8440 : }
8441 0 : arg2 = (char *)(buf2);
8442 : {
8443 0 : if (arg1->extension) free((char*)arg1->extension);
8444 0 : if (arg2) {
8445 0 : arg1->extension = (char *) malloc(strlen(arg2)+1);
8446 : strcpy((char*)arg1->extension,arg2);
8447 : } else {
8448 0 : arg1->extension = 0;
8449 : }
8450 : }
8451 : resultobj = SWIG_Py_Void();
8452 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8453 : return resultobj;
8454 0 : fail:
8455 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8456 : return NULL;
8457 : }
8458 :
8459 :
8460 1 : SWIGINTERN PyObject *_wrap_outputFormatObj_extension_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8461 : PyObject *resultobj = 0;
8462 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8463 1 : void *argp1 = 0 ;
8464 : int res1 = 0 ;
8465 1 : PyObject * obj0 = 0 ;
8466 : char *result = 0 ;
8467 :
8468 1 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_extension_get",&obj0)) SWIG_fail;
8469 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8470 1 : if (!SWIG_IsOK(res1)) {
8471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_extension_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8472 : }
8473 1 : arg1 = (outputFormatObj *)(argp1);
8474 1 : result = (char *) ((arg1)->extension);
8475 1 : resultobj = SWIG_FromCharPtr((const char *)result);
8476 1 : return resultobj;
8477 0 : fail:
8478 : return NULL;
8479 : }
8480 :
8481 :
8482 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_renderer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8483 : PyObject *resultobj = 0;
8484 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8485 : int arg2 ;
8486 0 : void *argp1 = 0 ;
8487 : int res1 = 0 ;
8488 : int val2 ;
8489 : int ecode2 = 0 ;
8490 0 : PyObject * obj0 = 0 ;
8491 0 : PyObject * obj1 = 0 ;
8492 :
8493 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_renderer_set",&obj0,&obj1)) SWIG_fail;
8494 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8495 0 : if (!SWIG_IsOK(res1)) {
8496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_renderer_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8497 : }
8498 0 : arg1 = (outputFormatObj *)(argp1);
8499 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8500 0 : if (!SWIG_IsOK(ecode2)) {
8501 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_renderer_set" "', argument " "2"" of type '" "int""'");
8502 : }
8503 : arg2 = (int)(val2);
8504 0 : if (arg1) (arg1)->renderer = arg2;
8505 : resultobj = SWIG_Py_Void();
8506 0 : return resultobj;
8507 0 : fail:
8508 : return NULL;
8509 : }
8510 :
8511 :
8512 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_renderer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8513 : PyObject *resultobj = 0;
8514 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8515 0 : void *argp1 = 0 ;
8516 : int res1 = 0 ;
8517 0 : PyObject * obj0 = 0 ;
8518 : int result;
8519 :
8520 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_renderer_get",&obj0)) SWIG_fail;
8521 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8522 0 : if (!SWIG_IsOK(res1)) {
8523 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_renderer_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8524 : }
8525 0 : arg1 = (outputFormatObj *)(argp1);
8526 0 : result = (int) ((arg1)->renderer);
8527 : resultobj = SWIG_From_int((int)(result));
8528 0 : return resultobj;
8529 0 : fail:
8530 : return NULL;
8531 : }
8532 :
8533 :
8534 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_imagemode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8535 : PyObject *resultobj = 0;
8536 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8537 : int arg2 ;
8538 0 : void *argp1 = 0 ;
8539 : int res1 = 0 ;
8540 : int val2 ;
8541 : int ecode2 = 0 ;
8542 0 : PyObject * obj0 = 0 ;
8543 0 : PyObject * obj1 = 0 ;
8544 :
8545 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_imagemode_set",&obj0,&obj1)) SWIG_fail;
8546 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8547 0 : if (!SWIG_IsOK(res1)) {
8548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_imagemode_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8549 : }
8550 0 : arg1 = (outputFormatObj *)(argp1);
8551 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8552 0 : if (!SWIG_IsOK(ecode2)) {
8553 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_imagemode_set" "', argument " "2"" of type '" "int""'");
8554 : }
8555 : arg2 = (int)(val2);
8556 0 : if (arg1) (arg1)->imagemode = arg2;
8557 : resultobj = SWIG_Py_Void();
8558 0 : return resultobj;
8559 0 : fail:
8560 : return NULL;
8561 : }
8562 :
8563 :
8564 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_imagemode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8565 : PyObject *resultobj = 0;
8566 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8567 0 : void *argp1 = 0 ;
8568 : int res1 = 0 ;
8569 0 : PyObject * obj0 = 0 ;
8570 : int result;
8571 :
8572 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_imagemode_get",&obj0)) SWIG_fail;
8573 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8574 0 : if (!SWIG_IsOK(res1)) {
8575 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_imagemode_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8576 : }
8577 0 : arg1 = (outputFormatObj *)(argp1);
8578 0 : result = (int) ((arg1)->imagemode);
8579 : resultobj = SWIG_From_int((int)(result));
8580 0 : return resultobj;
8581 0 : fail:
8582 : return NULL;
8583 : }
8584 :
8585 :
8586 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8587 : PyObject *resultobj = 0;
8588 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8589 : int arg2 ;
8590 0 : void *argp1 = 0 ;
8591 : int res1 = 0 ;
8592 : int val2 ;
8593 : int ecode2 = 0 ;
8594 0 : PyObject * obj0 = 0 ;
8595 0 : PyObject * obj1 = 0 ;
8596 :
8597 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_transparent_set",&obj0,&obj1)) SWIG_fail;
8598 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8599 0 : if (!SWIG_IsOK(res1)) {
8600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_transparent_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8601 : }
8602 0 : arg1 = (outputFormatObj *)(argp1);
8603 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8604 0 : if (!SWIG_IsOK(ecode2)) {
8605 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_transparent_set" "', argument " "2"" of type '" "int""'");
8606 : }
8607 : arg2 = (int)(val2);
8608 0 : if (arg1) (arg1)->transparent = arg2;
8609 : resultobj = SWIG_Py_Void();
8610 0 : return resultobj;
8611 0 : fail:
8612 : return NULL;
8613 : }
8614 :
8615 :
8616 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8617 : PyObject *resultobj = 0;
8618 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8619 0 : void *argp1 = 0 ;
8620 : int res1 = 0 ;
8621 0 : PyObject * obj0 = 0 ;
8622 : int result;
8623 :
8624 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_transparent_get",&obj0)) SWIG_fail;
8625 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8626 0 : if (!SWIG_IsOK(res1)) {
8627 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_transparent_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8628 : }
8629 0 : arg1 = (outputFormatObj *)(argp1);
8630 0 : result = (int) ((arg1)->transparent);
8631 : resultobj = SWIG_From_int((int)(result));
8632 0 : return resultobj;
8633 0 : fail:
8634 : return NULL;
8635 : }
8636 :
8637 :
8638 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_bands_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8639 : PyObject *resultobj = 0;
8640 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8641 : int arg2 ;
8642 0 : void *argp1 = 0 ;
8643 : int res1 = 0 ;
8644 : int val2 ;
8645 : int ecode2 = 0 ;
8646 0 : PyObject * obj0 = 0 ;
8647 0 : PyObject * obj1 = 0 ;
8648 :
8649 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_bands_set",&obj0,&obj1)) SWIG_fail;
8650 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8651 0 : if (!SWIG_IsOK(res1)) {
8652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_bands_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8653 : }
8654 0 : arg1 = (outputFormatObj *)(argp1);
8655 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8656 0 : if (!SWIG_IsOK(ecode2)) {
8657 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_bands_set" "', argument " "2"" of type '" "int""'");
8658 : }
8659 : arg2 = (int)(val2);
8660 0 : if (arg1) (arg1)->bands = arg2;
8661 : resultobj = SWIG_Py_Void();
8662 0 : return resultobj;
8663 0 : fail:
8664 : return NULL;
8665 : }
8666 :
8667 :
8668 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_bands_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8669 : PyObject *resultobj = 0;
8670 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8671 0 : void *argp1 = 0 ;
8672 : int res1 = 0 ;
8673 0 : PyObject * obj0 = 0 ;
8674 : int result;
8675 :
8676 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_bands_get",&obj0)) SWIG_fail;
8677 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8678 0 : if (!SWIG_IsOK(res1)) {
8679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_bands_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8680 : }
8681 0 : arg1 = (outputFormatObj *)(argp1);
8682 0 : result = (int) ((arg1)->bands);
8683 : resultobj = SWIG_From_int((int)(result));
8684 0 : return resultobj;
8685 0 : fail:
8686 : return NULL;
8687 : }
8688 :
8689 :
8690 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_inmapfile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8691 : PyObject *resultobj = 0;
8692 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8693 : int arg2 ;
8694 0 : void *argp1 = 0 ;
8695 : int res1 = 0 ;
8696 : int val2 ;
8697 : int ecode2 = 0 ;
8698 0 : PyObject * obj0 = 0 ;
8699 0 : PyObject * obj1 = 0 ;
8700 :
8701 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_inmapfile_set",&obj0,&obj1)) SWIG_fail;
8702 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8703 0 : if (!SWIG_IsOK(res1)) {
8704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_inmapfile_set" "', argument " "1"" of type '" "outputFormatObj *""'");
8705 : }
8706 0 : arg1 = (outputFormatObj *)(argp1);
8707 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8708 0 : if (!SWIG_IsOK(ecode2)) {
8709 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_inmapfile_set" "', argument " "2"" of type '" "int""'");
8710 : }
8711 : arg2 = (int)(val2);
8712 0 : if (arg1) (arg1)->inmapfile = arg2;
8713 : resultobj = SWIG_Py_Void();
8714 0 : return resultobj;
8715 0 : fail:
8716 : return NULL;
8717 : }
8718 :
8719 :
8720 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_inmapfile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8721 : PyObject *resultobj = 0;
8722 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8723 0 : void *argp1 = 0 ;
8724 : int res1 = 0 ;
8725 0 : PyObject * obj0 = 0 ;
8726 : int result;
8727 :
8728 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_inmapfile_get",&obj0)) SWIG_fail;
8729 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8730 0 : if (!SWIG_IsOK(res1)) {
8731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_inmapfile_get" "', argument " "1"" of type '" "outputFormatObj *""'");
8732 : }
8733 0 : arg1 = (outputFormatObj *)(argp1);
8734 0 : result = (int) ((arg1)->inmapfile);
8735 : resultobj = SWIG_From_int((int)(result));
8736 0 : return resultobj;
8737 0 : fail:
8738 : return NULL;
8739 : }
8740 :
8741 :
8742 1 : SWIGINTERN PyObject *_wrap_new_outputFormatObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 : PyObject *resultobj = 0;
8744 : char *arg1 = (char *) 0 ;
8745 : char *arg2 = (char *) NULL ;
8746 : int res1 ;
8747 1 : char *buf1 = 0 ;
8748 1 : int alloc1 = 0 ;
8749 : int res2 ;
8750 1 : char *buf2 = 0 ;
8751 1 : int alloc2 = 0 ;
8752 1 : PyObject * obj0 = 0 ;
8753 1 : PyObject * obj1 = 0 ;
8754 : outputFormatObj *result = 0 ;
8755 :
8756 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:new_outputFormatObj",&obj0,&obj1)) SWIG_fail;
8757 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
8758 1 : if (!SWIG_IsOK(res1)) {
8759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_outputFormatObj" "', argument " "1"" of type '" "char const *""'");
8760 : }
8761 1 : arg1 = (char *)(buf1);
8762 1 : if (obj1) {
8763 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8764 1 : if (!SWIG_IsOK(res2)) {
8765 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_outputFormatObj" "', argument " "2"" of type '" "char *""'");
8766 : }
8767 1 : arg2 = (char *)(buf2);
8768 : }
8769 : {
8770 1 : result = (outputFormatObj *)new_outputFormatObj((char const *)arg1,arg2); {
8771 1 : errorObj *ms_error = msGetErrorObj();
8772 :
8773 1 : switch(ms_error->code) {
8774 : case MS_NOERR:
8775 : break;
8776 0 : case MS_NOTFOUND:
8777 0 : msResetErrorList();
8778 0 : break;
8779 : case -1:
8780 : break;
8781 0 : case MS_IOERR:
8782 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8783 0 : _raise_ms_exception();
8784 0 : msResetErrorList();
8785 0 : return NULL;
8786 : }
8787 : default:
8788 1 : _raise_ms_exception();
8789 1 : msResetErrorList();
8790 1 : return NULL;
8791 : }
8792 :
8793 : }
8794 : }
8795 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, SWIG_POINTER_NEW | 0 );
8796 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8797 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8798 : return resultobj;
8799 0 : fail:
8800 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
8801 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8802 : return NULL;
8803 : }
8804 :
8805 :
8806 1 : SWIGINTERN PyObject *_wrap_delete_outputFormatObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8807 : PyObject *resultobj = 0;
8808 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8809 1 : void *argp1 = 0 ;
8810 : int res1 = 0 ;
8811 1 : PyObject * obj0 = 0 ;
8812 :
8813 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_outputFormatObj",&obj0)) SWIG_fail;
8814 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, SWIG_POINTER_DISOWN | 0 );
8815 1 : if (!SWIG_IsOK(res1)) {
8816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_outputFormatObj" "', argument " "1"" of type '" "outputFormatObj *""'");
8817 : }
8818 1 : arg1 = (outputFormatObj *)(argp1);
8819 : {
8820 : delete_outputFormatObj(arg1); {
8821 1 : errorObj *ms_error = msGetErrorObj();
8822 :
8823 1 : switch(ms_error->code) {
8824 : case MS_NOERR:
8825 : break;
8826 0 : case MS_NOTFOUND:
8827 0 : msResetErrorList();
8828 0 : break;
8829 : case -1:
8830 : break;
8831 0 : case MS_IOERR:
8832 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8833 0 : _raise_ms_exception();
8834 0 : msResetErrorList();
8835 0 : return NULL;
8836 : }
8837 : default:
8838 0 : _raise_ms_exception();
8839 0 : msResetErrorList();
8840 0 : return NULL;
8841 : }
8842 :
8843 : }
8844 : }
8845 : resultobj = SWIG_Py_Void();
8846 1 : return resultobj;
8847 0 : fail:
8848 : return NULL;
8849 : }
8850 :
8851 :
8852 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8853 : PyObject *resultobj = 0;
8854 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8855 : char *arg2 = (char *) 0 ;
8856 0 : void *argp1 = 0 ;
8857 : int res1 = 0 ;
8858 : int res2 ;
8859 0 : char *buf2 = 0 ;
8860 0 : int alloc2 = 0 ;
8861 0 : PyObject * obj0 = 0 ;
8862 0 : PyObject * obj1 = 0 ;
8863 :
8864 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_setExtension",&obj0,&obj1)) SWIG_fail;
8865 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8866 0 : if (!SWIG_IsOK(res1)) {
8867 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setExtension" "', argument " "1"" of type '" "outputFormatObj *""'");
8868 : }
8869 0 : arg1 = (outputFormatObj *)(argp1);
8870 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8871 0 : if (!SWIG_IsOK(res2)) {
8872 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setExtension" "', argument " "2"" of type '" "char const *""'");
8873 : }
8874 0 : arg2 = (char *)(buf2);
8875 : {
8876 : outputFormatObj_setExtension(arg1,(char const *)arg2); {
8877 0 : errorObj *ms_error = msGetErrorObj();
8878 :
8879 0 : switch(ms_error->code) {
8880 : case MS_NOERR:
8881 : break;
8882 0 : case MS_NOTFOUND:
8883 0 : msResetErrorList();
8884 0 : break;
8885 : case -1:
8886 : break;
8887 0 : case MS_IOERR:
8888 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8889 0 : _raise_ms_exception();
8890 0 : msResetErrorList();
8891 0 : return NULL;
8892 : }
8893 : default:
8894 0 : _raise_ms_exception();
8895 0 : msResetErrorList();
8896 0 : return NULL;
8897 : }
8898 :
8899 : }
8900 : }
8901 : resultobj = SWIG_Py_Void();
8902 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8903 : return resultobj;
8904 0 : fail:
8905 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8906 : return NULL;
8907 : }
8908 :
8909 :
8910 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setMimetype(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8911 : PyObject *resultobj = 0;
8912 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8913 : char *arg2 = (char *) 0 ;
8914 0 : void *argp1 = 0 ;
8915 : int res1 = 0 ;
8916 : int res2 ;
8917 0 : char *buf2 = 0 ;
8918 0 : int alloc2 = 0 ;
8919 0 : PyObject * obj0 = 0 ;
8920 0 : PyObject * obj1 = 0 ;
8921 :
8922 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_setMimetype",&obj0,&obj1)) SWIG_fail;
8923 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8924 0 : if (!SWIG_IsOK(res1)) {
8925 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setMimetype" "', argument " "1"" of type '" "outputFormatObj *""'");
8926 : }
8927 0 : arg1 = (outputFormatObj *)(argp1);
8928 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8929 0 : if (!SWIG_IsOK(res2)) {
8930 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setMimetype" "', argument " "2"" of type '" "char const *""'");
8931 : }
8932 0 : arg2 = (char *)(buf2);
8933 : {
8934 : outputFormatObj_setMimetype(arg1,(char const *)arg2); {
8935 0 : errorObj *ms_error = msGetErrorObj();
8936 :
8937 0 : switch(ms_error->code) {
8938 : case MS_NOERR:
8939 : break;
8940 0 : case MS_NOTFOUND:
8941 0 : msResetErrorList();
8942 0 : break;
8943 : case -1:
8944 : break;
8945 0 : case MS_IOERR:
8946 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
8947 0 : _raise_ms_exception();
8948 0 : msResetErrorList();
8949 0 : return NULL;
8950 : }
8951 : default:
8952 0 : _raise_ms_exception();
8953 0 : msResetErrorList();
8954 0 : return NULL;
8955 : }
8956 :
8957 : }
8958 : }
8959 : resultobj = SWIG_Py_Void();
8960 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8961 : return resultobj;
8962 0 : fail:
8963 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8964 : return NULL;
8965 : }
8966 :
8967 :
8968 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_setOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8969 : PyObject *resultobj = 0;
8970 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
8971 : char *arg2 = (char *) 0 ;
8972 : char *arg3 = (char *) 0 ;
8973 0 : void *argp1 = 0 ;
8974 : int res1 = 0 ;
8975 : int res2 ;
8976 0 : char *buf2 = 0 ;
8977 0 : int alloc2 = 0 ;
8978 : int res3 ;
8979 0 : char *buf3 = 0 ;
8980 0 : int alloc3 = 0 ;
8981 0 : PyObject * obj0 = 0 ;
8982 0 : PyObject * obj1 = 0 ;
8983 0 : PyObject * obj2 = 0 ;
8984 :
8985 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:outputFormatObj_setOption",&obj0,&obj1,&obj2)) SWIG_fail;
8986 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
8987 0 : if (!SWIG_IsOK(res1)) {
8988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_setOption" "', argument " "1"" of type '" "outputFormatObj *""'");
8989 : }
8990 0 : arg1 = (outputFormatObj *)(argp1);
8991 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8992 0 : if (!SWIG_IsOK(res2)) {
8993 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_setOption" "', argument " "2"" of type '" "char const *""'");
8994 : }
8995 0 : arg2 = (char *)(buf2);
8996 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
8997 0 : if (!SWIG_IsOK(res3)) {
8998 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "outputFormatObj_setOption" "', argument " "3"" of type '" "char const *""'");
8999 : }
9000 0 : arg3 = (char *)(buf3);
9001 : {
9002 : outputFormatObj_setOption(arg1,(char const *)arg2,(char const *)arg3); {
9003 0 : errorObj *ms_error = msGetErrorObj();
9004 :
9005 0 : switch(ms_error->code) {
9006 : case MS_NOERR:
9007 : break;
9008 0 : case MS_NOTFOUND:
9009 0 : msResetErrorList();
9010 0 : break;
9011 : case -1:
9012 : break;
9013 0 : case MS_IOERR:
9014 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9015 0 : _raise_ms_exception();
9016 0 : msResetErrorList();
9017 0 : return NULL;
9018 : }
9019 : default:
9020 0 : _raise_ms_exception();
9021 0 : msResetErrorList();
9022 0 : return NULL;
9023 : }
9024 :
9025 : }
9026 : }
9027 : resultobj = SWIG_Py_Void();
9028 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9029 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
9030 : return resultobj;
9031 0 : fail:
9032 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9033 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
9034 : return NULL;
9035 : }
9036 :
9037 :
9038 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9039 : PyObject *resultobj = 0;
9040 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
9041 0 : void *argp1 = 0 ;
9042 : int res1 = 0 ;
9043 0 : PyObject * obj0 = 0 ;
9044 : int result;
9045 :
9046 0 : if (!PyArg_ParseTuple(args,(char *)"O:outputFormatObj_validate",&obj0)) SWIG_fail;
9047 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
9048 0 : if (!SWIG_IsOK(res1)) {
9049 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_validate" "', argument " "1"" of type '" "outputFormatObj *""'");
9050 : }
9051 0 : arg1 = (outputFormatObj *)(argp1);
9052 : {
9053 : result = (int)outputFormatObj_validate(arg1); {
9054 0 : errorObj *ms_error = msGetErrorObj();
9055 :
9056 0 : switch(ms_error->code) {
9057 : case MS_NOERR:
9058 : break;
9059 0 : case MS_NOTFOUND:
9060 0 : msResetErrorList();
9061 0 : break;
9062 : case -1:
9063 : break;
9064 0 : case MS_IOERR:
9065 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9066 0 : _raise_ms_exception();
9067 0 : msResetErrorList();
9068 0 : return NULL;
9069 : }
9070 : default:
9071 0 : _raise_ms_exception();
9072 0 : msResetErrorList();
9073 0 : return NULL;
9074 : }
9075 :
9076 : }
9077 : }
9078 : resultobj = SWIG_From_int((int)(result));
9079 0 : return resultobj;
9080 0 : fail:
9081 : return NULL;
9082 : }
9083 :
9084 :
9085 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_getOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9086 : PyObject *resultobj = 0;
9087 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
9088 : char *arg2 = (char *) 0 ;
9089 : char *arg3 = (char *) "" ;
9090 0 : void *argp1 = 0 ;
9091 : int res1 = 0 ;
9092 : int res2 ;
9093 0 : char *buf2 = 0 ;
9094 0 : int alloc2 = 0 ;
9095 : int res3 ;
9096 0 : char *buf3 = 0 ;
9097 0 : int alloc3 = 0 ;
9098 0 : PyObject * obj0 = 0 ;
9099 0 : PyObject * obj1 = 0 ;
9100 0 : PyObject * obj2 = 0 ;
9101 : char *result = 0 ;
9102 :
9103 0 : if (!PyArg_ParseTuple(args,(char *)"OO|O:outputFormatObj_getOption",&obj0,&obj1,&obj2)) SWIG_fail;
9104 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
9105 0 : if (!SWIG_IsOK(res1)) {
9106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_getOption" "', argument " "1"" of type '" "outputFormatObj *""'");
9107 : }
9108 0 : arg1 = (outputFormatObj *)(argp1);
9109 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9110 0 : if (!SWIG_IsOK(res2)) {
9111 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_getOption" "', argument " "2"" of type '" "char const *""'");
9112 : }
9113 0 : arg2 = (char *)(buf2);
9114 0 : if (obj2) {
9115 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
9116 0 : if (!SWIG_IsOK(res3)) {
9117 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "outputFormatObj_getOption" "', argument " "3"" of type '" "char const *""'");
9118 : }
9119 0 : arg3 = (char *)(buf3);
9120 : }
9121 : {
9122 : result = (char *)outputFormatObj_getOption(arg1,(char const *)arg2,(char const *)arg3); {
9123 0 : errorObj *ms_error = msGetErrorObj();
9124 :
9125 0 : switch(ms_error->code) {
9126 : case MS_NOERR:
9127 : break;
9128 0 : case MS_NOTFOUND:
9129 0 : msResetErrorList();
9130 0 : break;
9131 : case -1:
9132 : break;
9133 0 : case MS_IOERR:
9134 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9135 0 : _raise_ms_exception();
9136 0 : msResetErrorList();
9137 0 : return NULL;
9138 : }
9139 : default:
9140 0 : _raise_ms_exception();
9141 0 : msResetErrorList();
9142 0 : return NULL;
9143 : }
9144 :
9145 : }
9146 : }
9147 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9148 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9149 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
9150 0 : free((char*)result);
9151 0 : return resultobj;
9152 0 : fail:
9153 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9154 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
9155 : return NULL;
9156 : }
9157 :
9158 :
9159 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_getOptionAt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9160 : PyObject *resultobj = 0;
9161 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
9162 : int arg2 ;
9163 0 : void *argp1 = 0 ;
9164 : int res1 = 0 ;
9165 : int val2 ;
9166 : int ecode2 = 0 ;
9167 0 : PyObject * obj0 = 0 ;
9168 0 : PyObject * obj1 = 0 ;
9169 : char *result = 0 ;
9170 :
9171 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_getOptionAt",&obj0,&obj1)) SWIG_fail;
9172 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
9173 0 : if (!SWIG_IsOK(res1)) {
9174 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_getOptionAt" "', argument " "1"" of type '" "outputFormatObj *""'");
9175 : }
9176 0 : arg1 = (outputFormatObj *)(argp1);
9177 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9178 0 : if (!SWIG_IsOK(ecode2)) {
9179 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "outputFormatObj_getOptionAt" "', argument " "2"" of type '" "int""'");
9180 : }
9181 : arg2 = (int)(val2);
9182 : {
9183 : result = (char *)outputFormatObj_getOptionAt(arg1,arg2); {
9184 0 : errorObj *ms_error = msGetErrorObj();
9185 :
9186 0 : switch(ms_error->code) {
9187 : case MS_NOERR:
9188 : break;
9189 0 : case MS_NOTFOUND:
9190 0 : msResetErrorList();
9191 0 : break;
9192 : case -1:
9193 : break;
9194 0 : case MS_IOERR:
9195 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9196 0 : _raise_ms_exception();
9197 0 : msResetErrorList();
9198 0 : return NULL;
9199 : }
9200 : default:
9201 0 : _raise_ms_exception();
9202 0 : msResetErrorList();
9203 0 : return NULL;
9204 : }
9205 :
9206 : }
9207 : }
9208 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9209 0 : free((char*)result);
9210 0 : return resultobj;
9211 0 : fail:
9212 : return NULL;
9213 : }
9214 :
9215 :
9216 0 : SWIGINTERN PyObject *_wrap_outputFormatObj_attachDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9217 : PyObject *resultobj = 0;
9218 : outputFormatObj *arg1 = (outputFormatObj *) 0 ;
9219 0 : void *arg2 = (void *) 0 ;
9220 0 : void *argp1 = 0 ;
9221 : int res1 = 0 ;
9222 : int res2 ;
9223 0 : PyObject * obj0 = 0 ;
9224 0 : PyObject * obj1 = 0 ;
9225 :
9226 0 : if (!PyArg_ParseTuple(args,(char *)"OO:outputFormatObj_attachDevice",&obj0,&obj1)) SWIG_fail;
9227 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_outputFormatObj, 0 | 0 );
9228 0 : if (!SWIG_IsOK(res1)) {
9229 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "outputFormatObj_attachDevice" "', argument " "1"" of type '" "outputFormatObj *""'");
9230 : }
9231 0 : arg1 = (outputFormatObj *)(argp1);
9232 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
9233 0 : if (!SWIG_IsOK(res2)) {
9234 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "outputFormatObj_attachDevice" "', argument " "2"" of type '" "void *""'");
9235 : }
9236 : {
9237 0 : outputFormatObj_attachDevice(arg1,arg2); {
9238 0 : errorObj *ms_error = msGetErrorObj();
9239 :
9240 0 : switch(ms_error->code) {
9241 : case MS_NOERR:
9242 : break;
9243 0 : case MS_NOTFOUND:
9244 0 : msResetErrorList();
9245 0 : break;
9246 : case -1:
9247 : break;
9248 0 : case MS_IOERR:
9249 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9250 0 : _raise_ms_exception();
9251 0 : msResetErrorList();
9252 0 : return NULL;
9253 : }
9254 : default:
9255 0 : _raise_ms_exception();
9256 0 : msResetErrorList();
9257 0 : return NULL;
9258 : }
9259 :
9260 : }
9261 : }
9262 : resultobj = SWIG_Py_Void();
9263 0 : return resultobj;
9264 0 : fail:
9265 : return NULL;
9266 : }
9267 :
9268 :
9269 1 : SWIGINTERN PyObject *outputFormatObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9270 : PyObject *obj;
9271 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
9272 1 : SWIG_TypeNewClientData(SWIGTYPE_p_outputFormatObj, SWIG_NewClientData(obj));
9273 1 : return SWIG_Py_Void();
9274 : }
9275 :
9276 0 : SWIGINTERN PyObject *_wrap_queryMapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9277 : PyObject *resultobj = 0;
9278 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9279 : int arg2 ;
9280 0 : void *argp1 = 0 ;
9281 : int res1 = 0 ;
9282 : int val2 ;
9283 : int ecode2 = 0 ;
9284 0 : PyObject * obj0 = 0 ;
9285 0 : PyObject * obj1 = 0 ;
9286 :
9287 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_height_set",&obj0,&obj1)) SWIG_fail;
9288 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9289 0 : if (!SWIG_IsOK(res1)) {
9290 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_height_set" "', argument " "1"" of type '" "queryMapObj *""'");
9291 : }
9292 0 : arg1 = (queryMapObj *)(argp1);
9293 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9294 0 : if (!SWIG_IsOK(ecode2)) {
9295 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_height_set" "', argument " "2"" of type '" "int""'");
9296 : }
9297 : arg2 = (int)(val2);
9298 0 : if (arg1) (arg1)->height = arg2;
9299 : resultobj = SWIG_Py_Void();
9300 0 : return resultobj;
9301 0 : fail:
9302 : return NULL;
9303 : }
9304 :
9305 :
9306 0 : SWIGINTERN PyObject *_wrap_queryMapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9307 : PyObject *resultobj = 0;
9308 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9309 0 : void *argp1 = 0 ;
9310 : int res1 = 0 ;
9311 0 : PyObject * obj0 = 0 ;
9312 : int result;
9313 :
9314 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_height_get",&obj0)) SWIG_fail;
9315 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9316 0 : if (!SWIG_IsOK(res1)) {
9317 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_height_get" "', argument " "1"" of type '" "queryMapObj *""'");
9318 : }
9319 0 : arg1 = (queryMapObj *)(argp1);
9320 0 : result = (int) ((arg1)->height);
9321 : resultobj = SWIG_From_int((int)(result));
9322 0 : return resultobj;
9323 0 : fail:
9324 : return NULL;
9325 : }
9326 :
9327 :
9328 0 : SWIGINTERN PyObject *_wrap_queryMapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9329 : PyObject *resultobj = 0;
9330 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9331 : int arg2 ;
9332 0 : void *argp1 = 0 ;
9333 : int res1 = 0 ;
9334 : int val2 ;
9335 : int ecode2 = 0 ;
9336 0 : PyObject * obj0 = 0 ;
9337 0 : PyObject * obj1 = 0 ;
9338 :
9339 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_width_set",&obj0,&obj1)) SWIG_fail;
9340 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9341 0 : if (!SWIG_IsOK(res1)) {
9342 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_width_set" "', argument " "1"" of type '" "queryMapObj *""'");
9343 : }
9344 0 : arg1 = (queryMapObj *)(argp1);
9345 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9346 0 : if (!SWIG_IsOK(ecode2)) {
9347 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_width_set" "', argument " "2"" of type '" "int""'");
9348 : }
9349 : arg2 = (int)(val2);
9350 0 : if (arg1) (arg1)->width = arg2;
9351 : resultobj = SWIG_Py_Void();
9352 0 : return resultobj;
9353 0 : fail:
9354 : return NULL;
9355 : }
9356 :
9357 :
9358 0 : SWIGINTERN PyObject *_wrap_queryMapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9359 : PyObject *resultobj = 0;
9360 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9361 0 : void *argp1 = 0 ;
9362 : int res1 = 0 ;
9363 0 : PyObject * obj0 = 0 ;
9364 : int result;
9365 :
9366 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_width_get",&obj0)) SWIG_fail;
9367 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9368 0 : if (!SWIG_IsOK(res1)) {
9369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_width_get" "', argument " "1"" of type '" "queryMapObj *""'");
9370 : }
9371 0 : arg1 = (queryMapObj *)(argp1);
9372 0 : result = (int) ((arg1)->width);
9373 : resultobj = SWIG_From_int((int)(result));
9374 0 : return resultobj;
9375 0 : fail:
9376 : return NULL;
9377 : }
9378 :
9379 :
9380 0 : SWIGINTERN PyObject *_wrap_queryMapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9381 : PyObject *resultobj = 0;
9382 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9383 : int arg2 ;
9384 0 : void *argp1 = 0 ;
9385 : int res1 = 0 ;
9386 : int val2 ;
9387 : int ecode2 = 0 ;
9388 0 : PyObject * obj0 = 0 ;
9389 0 : PyObject * obj1 = 0 ;
9390 :
9391 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_status_set",&obj0,&obj1)) SWIG_fail;
9392 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9393 0 : if (!SWIG_IsOK(res1)) {
9394 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_status_set" "', argument " "1"" of type '" "queryMapObj *""'");
9395 : }
9396 0 : arg1 = (queryMapObj *)(argp1);
9397 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9398 0 : if (!SWIG_IsOK(ecode2)) {
9399 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_status_set" "', argument " "2"" of type '" "int""'");
9400 : }
9401 : arg2 = (int)(val2);
9402 0 : if (arg1) (arg1)->status = arg2;
9403 : resultobj = SWIG_Py_Void();
9404 0 : return resultobj;
9405 0 : fail:
9406 : return NULL;
9407 : }
9408 :
9409 :
9410 0 : SWIGINTERN PyObject *_wrap_queryMapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9411 : PyObject *resultobj = 0;
9412 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9413 0 : void *argp1 = 0 ;
9414 : int res1 = 0 ;
9415 0 : PyObject * obj0 = 0 ;
9416 : int result;
9417 :
9418 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_status_get",&obj0)) SWIG_fail;
9419 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9420 0 : if (!SWIG_IsOK(res1)) {
9421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_status_get" "', argument " "1"" of type '" "queryMapObj *""'");
9422 : }
9423 0 : arg1 = (queryMapObj *)(argp1);
9424 0 : result = (int) ((arg1)->status);
9425 : resultobj = SWIG_From_int((int)(result));
9426 0 : return resultobj;
9427 0 : fail:
9428 : return NULL;
9429 : }
9430 :
9431 :
9432 0 : SWIGINTERN PyObject *_wrap_queryMapObj_style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9433 : PyObject *resultobj = 0;
9434 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9435 : int arg2 ;
9436 0 : void *argp1 = 0 ;
9437 : int res1 = 0 ;
9438 : int val2 ;
9439 : int ecode2 = 0 ;
9440 0 : PyObject * obj0 = 0 ;
9441 0 : PyObject * obj1 = 0 ;
9442 :
9443 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_style_set",&obj0,&obj1)) SWIG_fail;
9444 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9445 0 : if (!SWIG_IsOK(res1)) {
9446 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_style_set" "', argument " "1"" of type '" "queryMapObj *""'");
9447 : }
9448 0 : arg1 = (queryMapObj *)(argp1);
9449 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9450 0 : if (!SWIG_IsOK(ecode2)) {
9451 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "queryMapObj_style_set" "', argument " "2"" of type '" "int""'");
9452 : }
9453 : arg2 = (int)(val2);
9454 0 : if (arg1) (arg1)->style = arg2;
9455 : resultobj = SWIG_Py_Void();
9456 0 : return resultobj;
9457 0 : fail:
9458 : return NULL;
9459 : }
9460 :
9461 :
9462 0 : SWIGINTERN PyObject *_wrap_queryMapObj_style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9463 : PyObject *resultobj = 0;
9464 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9465 0 : void *argp1 = 0 ;
9466 : int res1 = 0 ;
9467 0 : PyObject * obj0 = 0 ;
9468 : int result;
9469 :
9470 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_style_get",&obj0)) SWIG_fail;
9471 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9472 0 : if (!SWIG_IsOK(res1)) {
9473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_style_get" "', argument " "1"" of type '" "queryMapObj *""'");
9474 : }
9475 0 : arg1 = (queryMapObj *)(argp1);
9476 0 : result = (int) ((arg1)->style);
9477 : resultobj = SWIG_From_int((int)(result));
9478 0 : return resultobj;
9479 0 : fail:
9480 : return NULL;
9481 : }
9482 :
9483 :
9484 0 : SWIGINTERN PyObject *_wrap_queryMapObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9485 : PyObject *resultobj = 0;
9486 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9487 : colorObj *arg2 = (colorObj *) 0 ;
9488 0 : void *argp1 = 0 ;
9489 : int res1 = 0 ;
9490 0 : void *argp2 = 0 ;
9491 : int res2 = 0 ;
9492 0 : PyObject * obj0 = 0 ;
9493 0 : PyObject * obj1 = 0 ;
9494 :
9495 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_color_set",&obj0,&obj1)) SWIG_fail;
9496 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9497 0 : if (!SWIG_IsOK(res1)) {
9498 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_color_set" "', argument " "1"" of type '" "queryMapObj *""'");
9499 : }
9500 0 : arg1 = (queryMapObj *)(argp1);
9501 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
9502 0 : if (!SWIG_IsOK(res2)) {
9503 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "queryMapObj_color_set" "', argument " "2"" of type '" "colorObj *""'");
9504 : }
9505 0 : arg2 = (colorObj *)(argp2);
9506 0 : if (arg1) (arg1)->color = *arg2;
9507 : resultobj = SWIG_Py_Void();
9508 0 : return resultobj;
9509 0 : fail:
9510 : return NULL;
9511 : }
9512 :
9513 :
9514 0 : SWIGINTERN PyObject *_wrap_queryMapObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9515 : PyObject *resultobj = 0;
9516 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9517 0 : void *argp1 = 0 ;
9518 : int res1 = 0 ;
9519 0 : PyObject * obj0 = 0 ;
9520 : colorObj *result = 0 ;
9521 :
9522 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_color_get",&obj0)) SWIG_fail;
9523 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9524 0 : if (!SWIG_IsOK(res1)) {
9525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_color_get" "', argument " "1"" of type '" "queryMapObj *""'");
9526 : }
9527 0 : arg1 = (queryMapObj *)(argp1);
9528 0 : result = (colorObj *)& ((arg1)->color);
9529 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
9530 0 : return resultobj;
9531 0 : fail:
9532 : return NULL;
9533 : }
9534 :
9535 :
9536 0 : SWIGINTERN PyObject *_wrap_queryMapObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 : PyObject *resultobj = 0;
9538 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9539 : char *arg2 = (char *) 0 ;
9540 0 : void *argp1 = 0 ;
9541 : int res1 = 0 ;
9542 : int res2 ;
9543 0 : char *buf2 = 0 ;
9544 0 : int alloc2 = 0 ;
9545 0 : PyObject * obj0 = 0 ;
9546 0 : PyObject * obj1 = 0 ;
9547 : int result;
9548 :
9549 0 : if (!PyArg_ParseTuple(args,(char *)"OO:queryMapObj_updateFromString",&obj0,&obj1)) SWIG_fail;
9550 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9551 0 : if (!SWIG_IsOK(res1)) {
9552 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_updateFromString" "', argument " "1"" of type '" "queryMapObj *""'");
9553 : }
9554 0 : arg1 = (queryMapObj *)(argp1);
9555 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9556 0 : if (!SWIG_IsOK(res2)) {
9557 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "queryMapObj_updateFromString" "', argument " "2"" of type '" "char *""'");
9558 : }
9559 0 : arg2 = (char *)(buf2);
9560 : {
9561 : result = (int)queryMapObj_updateFromString(arg1,arg2); {
9562 0 : errorObj *ms_error = msGetErrorObj();
9563 :
9564 0 : switch(ms_error->code) {
9565 : case MS_NOERR:
9566 : break;
9567 0 : case MS_NOTFOUND:
9568 0 : msResetErrorList();
9569 0 : break;
9570 : case -1:
9571 : break;
9572 0 : case MS_IOERR:
9573 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9574 0 : _raise_ms_exception();
9575 0 : msResetErrorList();
9576 0 : return NULL;
9577 : }
9578 : default:
9579 0 : _raise_ms_exception();
9580 0 : msResetErrorList();
9581 0 : return NULL;
9582 : }
9583 :
9584 : }
9585 : }
9586 : resultobj = SWIG_From_int((int)(result));
9587 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9588 : return resultobj;
9589 0 : fail:
9590 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9591 : return NULL;
9592 : }
9593 :
9594 :
9595 0 : SWIGINTERN PyObject *_wrap_queryMapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9596 : PyObject *resultobj = 0;
9597 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9598 0 : void *argp1 = 0 ;
9599 : int res1 = 0 ;
9600 0 : PyObject * obj0 = 0 ;
9601 : char *result = 0 ;
9602 :
9603 0 : if (!PyArg_ParseTuple(args,(char *)"O:queryMapObj_convertToString",&obj0)) SWIG_fail;
9604 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, 0 | 0 );
9605 0 : if (!SWIG_IsOK(res1)) {
9606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "queryMapObj_convertToString" "', argument " "1"" of type '" "queryMapObj *""'");
9607 : }
9608 0 : arg1 = (queryMapObj *)(argp1);
9609 : {
9610 : result = (char *)queryMapObj_convertToString(arg1); {
9611 0 : errorObj *ms_error = msGetErrorObj();
9612 :
9613 0 : switch(ms_error->code) {
9614 : case MS_NOERR:
9615 : break;
9616 0 : case MS_NOTFOUND:
9617 0 : msResetErrorList();
9618 0 : break;
9619 : case -1:
9620 : break;
9621 0 : case MS_IOERR:
9622 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9623 0 : _raise_ms_exception();
9624 0 : msResetErrorList();
9625 0 : return NULL;
9626 : }
9627 : default:
9628 0 : _raise_ms_exception();
9629 0 : msResetErrorList();
9630 0 : return NULL;
9631 : }
9632 :
9633 : }
9634 : }
9635 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9636 0 : free((char*)result);
9637 0 : return resultobj;
9638 0 : fail:
9639 : return NULL;
9640 : }
9641 :
9642 :
9643 0 : SWIGINTERN PyObject *_wrap_new_queryMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9644 : PyObject *resultobj = 0;
9645 : queryMapObj *result = 0 ;
9646 :
9647 0 : if (!PyArg_ParseTuple(args,(char *)":new_queryMapObj")) SWIG_fail;
9648 : {
9649 0 : result = (queryMapObj *)calloc(1, sizeof(queryMapObj)); {
9650 0 : errorObj *ms_error = msGetErrorObj();
9651 :
9652 0 : switch(ms_error->code) {
9653 : case MS_NOERR:
9654 : break;
9655 0 : case MS_NOTFOUND:
9656 0 : msResetErrorList();
9657 0 : break;
9658 : case -1:
9659 : break;
9660 0 : case MS_IOERR:
9661 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9662 0 : _raise_ms_exception();
9663 0 : msResetErrorList();
9664 0 : return NULL;
9665 : }
9666 : default:
9667 0 : _raise_ms_exception();
9668 0 : msResetErrorList();
9669 0 : return NULL;
9670 : }
9671 :
9672 : }
9673 : }
9674 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_queryMapObj, SWIG_POINTER_NEW | 0 );
9675 0 : return resultobj;
9676 0 : fail:
9677 : return NULL;
9678 : }
9679 :
9680 :
9681 0 : SWIGINTERN PyObject *_wrap_delete_queryMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9682 : PyObject *resultobj = 0;
9683 : queryMapObj *arg1 = (queryMapObj *) 0 ;
9684 0 : void *argp1 = 0 ;
9685 : int res1 = 0 ;
9686 0 : PyObject * obj0 = 0 ;
9687 :
9688 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_queryMapObj",&obj0)) SWIG_fail;
9689 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_queryMapObj, SWIG_POINTER_DISOWN | 0 );
9690 0 : if (!SWIG_IsOK(res1)) {
9691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_queryMapObj" "', argument " "1"" of type '" "queryMapObj *""'");
9692 : }
9693 0 : arg1 = (queryMapObj *)(argp1);
9694 : {
9695 0 : free((char *) arg1); {
9696 0 : errorObj *ms_error = msGetErrorObj();
9697 :
9698 0 : switch(ms_error->code) {
9699 : case MS_NOERR:
9700 : break;
9701 0 : case MS_NOTFOUND:
9702 0 : msResetErrorList();
9703 0 : break;
9704 : case -1:
9705 : break;
9706 0 : case MS_IOERR:
9707 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
9708 0 : _raise_ms_exception();
9709 0 : msResetErrorList();
9710 0 : return NULL;
9711 : }
9712 : default:
9713 0 : _raise_ms_exception();
9714 0 : msResetErrorList();
9715 0 : return NULL;
9716 : }
9717 :
9718 : }
9719 : }
9720 : resultobj = SWIG_Py_Void();
9721 0 : return resultobj;
9722 0 : fail:
9723 : return NULL;
9724 : }
9725 :
9726 :
9727 1 : SWIGINTERN PyObject *queryMapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9728 : PyObject *obj;
9729 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
9730 1 : SWIG_TypeNewClientData(SWIGTYPE_p_queryMapObj, SWIG_NewClientData(obj));
9731 1 : return SWIG_Py_Void();
9732 : }
9733 :
9734 0 : SWIGINTERN PyObject *_wrap_webObj_log_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9735 : PyObject *resultobj = 0;
9736 : webObj *arg1 = (webObj *) 0 ;
9737 : char *arg2 = (char *) 0 ;
9738 0 : void *argp1 = 0 ;
9739 : int res1 = 0 ;
9740 : int res2 ;
9741 0 : char *buf2 = 0 ;
9742 0 : int alloc2 = 0 ;
9743 0 : PyObject * obj0 = 0 ;
9744 0 : PyObject * obj1 = 0 ;
9745 :
9746 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_log_set",&obj0,&obj1)) SWIG_fail;
9747 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9748 0 : if (!SWIG_IsOK(res1)) {
9749 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_log_set" "', argument " "1"" of type '" "webObj *""'");
9750 : }
9751 0 : arg1 = (webObj *)(argp1);
9752 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9753 0 : if (!SWIG_IsOK(res2)) {
9754 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_log_set" "', argument " "2"" of type '" "char *""'");
9755 : }
9756 0 : arg2 = (char *)(buf2);
9757 : {
9758 0 : if (arg1->log) free((char*)arg1->log);
9759 0 : if (arg2) {
9760 0 : arg1->log = (char *) malloc(strlen(arg2)+1);
9761 : strcpy((char*)arg1->log,arg2);
9762 : } else {
9763 0 : arg1->log = 0;
9764 : }
9765 : }
9766 : resultobj = SWIG_Py_Void();
9767 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9768 : return resultobj;
9769 0 : fail:
9770 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9771 : return NULL;
9772 : }
9773 :
9774 :
9775 0 : SWIGINTERN PyObject *_wrap_webObj_log_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9776 : PyObject *resultobj = 0;
9777 : webObj *arg1 = (webObj *) 0 ;
9778 0 : void *argp1 = 0 ;
9779 : int res1 = 0 ;
9780 0 : PyObject * obj0 = 0 ;
9781 : char *result = 0 ;
9782 :
9783 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_log_get",&obj0)) SWIG_fail;
9784 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9785 0 : if (!SWIG_IsOK(res1)) {
9786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_log_get" "', argument " "1"" of type '" "webObj *""'");
9787 : }
9788 0 : arg1 = (webObj *)(argp1);
9789 0 : result = (char *) ((arg1)->log);
9790 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9791 0 : return resultobj;
9792 0 : fail:
9793 : return NULL;
9794 : }
9795 :
9796 :
9797 1 : SWIGINTERN PyObject *_wrap_webObj_imagepath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9798 : PyObject *resultobj = 0;
9799 : webObj *arg1 = (webObj *) 0 ;
9800 : char *arg2 = (char *) 0 ;
9801 1 : void *argp1 = 0 ;
9802 : int res1 = 0 ;
9803 : int res2 ;
9804 1 : char *buf2 = 0 ;
9805 1 : int alloc2 = 0 ;
9806 1 : PyObject * obj0 = 0 ;
9807 1 : PyObject * obj1 = 0 ;
9808 :
9809 1 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_imagepath_set",&obj0,&obj1)) SWIG_fail;
9810 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9811 1 : if (!SWIG_IsOK(res1)) {
9812 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imagepath_set" "', argument " "1"" of type '" "webObj *""'");
9813 : }
9814 1 : arg1 = (webObj *)(argp1);
9815 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9816 1 : if (!SWIG_IsOK(res2)) {
9817 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_imagepath_set" "', argument " "2"" of type '" "char *""'");
9818 : }
9819 1 : arg2 = (char *)(buf2);
9820 : {
9821 1 : if (arg1->imagepath) free((char*)arg1->imagepath);
9822 1 : if (arg2) {
9823 1 : arg1->imagepath = (char *) malloc(strlen(arg2)+1);
9824 : strcpy((char*)arg1->imagepath,arg2);
9825 : } else {
9826 0 : arg1->imagepath = 0;
9827 : }
9828 : }
9829 : resultobj = SWIG_Py_Void();
9830 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9831 : return resultobj;
9832 0 : fail:
9833 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9834 : return NULL;
9835 : }
9836 :
9837 :
9838 1 : SWIGINTERN PyObject *_wrap_webObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9839 : PyObject *resultobj = 0;
9840 : webObj *arg1 = (webObj *) 0 ;
9841 1 : void *argp1 = 0 ;
9842 : int res1 = 0 ;
9843 1 : PyObject * obj0 = 0 ;
9844 : char *result = 0 ;
9845 :
9846 1 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_imagepath_get",&obj0)) SWIG_fail;
9847 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9848 1 : if (!SWIG_IsOK(res1)) {
9849 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imagepath_get" "', argument " "1"" of type '" "webObj *""'");
9850 : }
9851 1 : arg1 = (webObj *)(argp1);
9852 1 : result = (char *) ((arg1)->imagepath);
9853 1 : resultobj = SWIG_FromCharPtr((const char *)result);
9854 1 : return resultobj;
9855 0 : fail:
9856 : return NULL;
9857 : }
9858 :
9859 :
9860 0 : SWIGINTERN PyObject *_wrap_webObj_imageurl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9861 : PyObject *resultobj = 0;
9862 : webObj *arg1 = (webObj *) 0 ;
9863 : char *arg2 = (char *) 0 ;
9864 0 : void *argp1 = 0 ;
9865 : int res1 = 0 ;
9866 : int res2 ;
9867 0 : char *buf2 = 0 ;
9868 0 : int alloc2 = 0 ;
9869 0 : PyObject * obj0 = 0 ;
9870 0 : PyObject * obj1 = 0 ;
9871 :
9872 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_imageurl_set",&obj0,&obj1)) SWIG_fail;
9873 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9874 0 : if (!SWIG_IsOK(res1)) {
9875 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imageurl_set" "', argument " "1"" of type '" "webObj *""'");
9876 : }
9877 0 : arg1 = (webObj *)(argp1);
9878 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9879 0 : if (!SWIG_IsOK(res2)) {
9880 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_imageurl_set" "', argument " "2"" of type '" "char *""'");
9881 : }
9882 0 : arg2 = (char *)(buf2);
9883 : {
9884 0 : if (arg1->imageurl) free((char*)arg1->imageurl);
9885 0 : if (arg2) {
9886 0 : arg1->imageurl = (char *) malloc(strlen(arg2)+1);
9887 : strcpy((char*)arg1->imageurl,arg2);
9888 : } else {
9889 0 : arg1->imageurl = 0;
9890 : }
9891 : }
9892 : resultobj = SWIG_Py_Void();
9893 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9894 : return resultobj;
9895 0 : fail:
9896 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9897 : return NULL;
9898 : }
9899 :
9900 :
9901 0 : SWIGINTERN PyObject *_wrap_webObj_imageurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9902 : PyObject *resultobj = 0;
9903 : webObj *arg1 = (webObj *) 0 ;
9904 0 : void *argp1 = 0 ;
9905 : int res1 = 0 ;
9906 0 : PyObject * obj0 = 0 ;
9907 : char *result = 0 ;
9908 :
9909 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_imageurl_get",&obj0)) SWIG_fail;
9910 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9911 0 : if (!SWIG_IsOK(res1)) {
9912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_imageurl_get" "', argument " "1"" of type '" "webObj *""'");
9913 : }
9914 0 : arg1 = (webObj *)(argp1);
9915 0 : result = (char *) ((arg1)->imageurl);
9916 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9917 0 : return resultobj;
9918 0 : fail:
9919 : return NULL;
9920 : }
9921 :
9922 :
9923 0 : SWIGINTERN PyObject *_wrap_webObj_temppath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9924 : PyObject *resultobj = 0;
9925 : webObj *arg1 = (webObj *) 0 ;
9926 : char *arg2 = (char *) 0 ;
9927 0 : void *argp1 = 0 ;
9928 : int res1 = 0 ;
9929 : int res2 ;
9930 0 : char *buf2 = 0 ;
9931 0 : int alloc2 = 0 ;
9932 0 : PyObject * obj0 = 0 ;
9933 0 : PyObject * obj1 = 0 ;
9934 :
9935 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_temppath_set",&obj0,&obj1)) SWIG_fail;
9936 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9937 0 : if (!SWIG_IsOK(res1)) {
9938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_temppath_set" "', argument " "1"" of type '" "webObj *""'");
9939 : }
9940 0 : arg1 = (webObj *)(argp1);
9941 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9942 0 : if (!SWIG_IsOK(res2)) {
9943 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_temppath_set" "', argument " "2"" of type '" "char *""'");
9944 : }
9945 0 : arg2 = (char *)(buf2);
9946 : {
9947 0 : if (arg1->temppath) free((char*)arg1->temppath);
9948 0 : if (arg2) {
9949 0 : arg1->temppath = (char *) malloc(strlen(arg2)+1);
9950 : strcpy((char*)arg1->temppath,arg2);
9951 : } else {
9952 0 : arg1->temppath = 0;
9953 : }
9954 : }
9955 : resultobj = SWIG_Py_Void();
9956 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9957 : return resultobj;
9958 0 : fail:
9959 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9960 : return NULL;
9961 : }
9962 :
9963 :
9964 0 : SWIGINTERN PyObject *_wrap_webObj_temppath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9965 : PyObject *resultobj = 0;
9966 : webObj *arg1 = (webObj *) 0 ;
9967 0 : void *argp1 = 0 ;
9968 : int res1 = 0 ;
9969 0 : PyObject * obj0 = 0 ;
9970 : char *result = 0 ;
9971 :
9972 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_temppath_get",&obj0)) SWIG_fail;
9973 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9974 0 : if (!SWIG_IsOK(res1)) {
9975 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_temppath_get" "', argument " "1"" of type '" "webObj *""'");
9976 : }
9977 0 : arg1 = (webObj *)(argp1);
9978 0 : result = (char *) ((arg1)->temppath);
9979 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9980 0 : return resultobj;
9981 0 : fail:
9982 : return NULL;
9983 : }
9984 :
9985 :
9986 0 : SWIGINTERN PyObject *_wrap_webObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9987 : PyObject *resultobj = 0;
9988 : webObj *arg1 = (webObj *) 0 ;
9989 0 : void *argp1 = 0 ;
9990 : int res1 = 0 ;
9991 0 : PyObject * obj0 = 0 ;
9992 : struct mapObj *result = 0 ;
9993 :
9994 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_map_get",&obj0)) SWIG_fail;
9995 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
9996 0 : if (!SWIG_IsOK(res1)) {
9997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_map_get" "', argument " "1"" of type '" "webObj *""'");
9998 : }
9999 0 : arg1 = (webObj *)(argp1);
10000 0 : result = (struct mapObj *) ((arg1)->map);
10001 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 | 0 );
10002 0 : return resultobj;
10003 0 : fail:
10004 : return NULL;
10005 : }
10006 :
10007 :
10008 0 : SWIGINTERN PyObject *_wrap_webObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10009 : PyObject *resultobj = 0;
10010 : webObj *arg1 = (webObj *) 0 ;
10011 : char *arg2 = (char *) 0 ;
10012 0 : void *argp1 = 0 ;
10013 : int res1 = 0 ;
10014 : int res2 ;
10015 0 : char *buf2 = 0 ;
10016 0 : int alloc2 = 0 ;
10017 0 : PyObject * obj0 = 0 ;
10018 0 : PyObject * obj1 = 0 ;
10019 :
10020 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_template_set",&obj0,&obj1)) SWIG_fail;
10021 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10022 0 : if (!SWIG_IsOK(res1)) {
10023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_template_set" "', argument " "1"" of type '" "webObj *""'");
10024 : }
10025 0 : arg1 = (webObj *)(argp1);
10026 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10027 0 : if (!SWIG_IsOK(res2)) {
10028 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_template_set" "', argument " "2"" of type '" "char *""'");
10029 : }
10030 0 : arg2 = (char *)(buf2);
10031 : {
10032 0 : if (arg1->template) free((char*)arg1->template);
10033 0 : if (arg2) {
10034 0 : arg1->template = (char *) malloc(strlen(arg2)+1);
10035 : strcpy((char*)arg1->template,arg2);
10036 : } else {
10037 0 : arg1->template = 0;
10038 : }
10039 : }
10040 : resultobj = SWIG_Py_Void();
10041 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10042 : return resultobj;
10043 0 : fail:
10044 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10045 : return NULL;
10046 : }
10047 :
10048 :
10049 0 : SWIGINTERN PyObject *_wrap_webObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10050 : PyObject *resultobj = 0;
10051 : webObj *arg1 = (webObj *) 0 ;
10052 0 : void *argp1 = 0 ;
10053 : int res1 = 0 ;
10054 0 : PyObject * obj0 = 0 ;
10055 : char *result = 0 ;
10056 :
10057 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_template_get",&obj0)) SWIG_fail;
10058 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10059 0 : if (!SWIG_IsOK(res1)) {
10060 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_template_get" "', argument " "1"" of type '" "webObj *""'");
10061 : }
10062 0 : arg1 = (webObj *)(argp1);
10063 0 : result = (char *) ((arg1)->template);
10064 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10065 0 : return resultobj;
10066 0 : fail:
10067 : return NULL;
10068 : }
10069 :
10070 :
10071 0 : SWIGINTERN PyObject *_wrap_webObj_header_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10072 : PyObject *resultobj = 0;
10073 : webObj *arg1 = (webObj *) 0 ;
10074 : char *arg2 = (char *) 0 ;
10075 0 : void *argp1 = 0 ;
10076 : int res1 = 0 ;
10077 : int res2 ;
10078 0 : char *buf2 = 0 ;
10079 0 : int alloc2 = 0 ;
10080 0 : PyObject * obj0 = 0 ;
10081 0 : PyObject * obj1 = 0 ;
10082 :
10083 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_header_set",&obj0,&obj1)) SWIG_fail;
10084 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10085 0 : if (!SWIG_IsOK(res1)) {
10086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_header_set" "', argument " "1"" of type '" "webObj *""'");
10087 : }
10088 0 : arg1 = (webObj *)(argp1);
10089 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10090 0 : if (!SWIG_IsOK(res2)) {
10091 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_header_set" "', argument " "2"" of type '" "char *""'");
10092 : }
10093 0 : arg2 = (char *)(buf2);
10094 : {
10095 0 : if (arg1->header) free((char*)arg1->header);
10096 0 : if (arg2) {
10097 0 : arg1->header = (char *) malloc(strlen(arg2)+1);
10098 : strcpy((char*)arg1->header,arg2);
10099 : } else {
10100 0 : arg1->header = 0;
10101 : }
10102 : }
10103 : resultobj = SWIG_Py_Void();
10104 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10105 : return resultobj;
10106 0 : fail:
10107 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10108 : return NULL;
10109 : }
10110 :
10111 :
10112 0 : SWIGINTERN PyObject *_wrap_webObj_header_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10113 : PyObject *resultobj = 0;
10114 : webObj *arg1 = (webObj *) 0 ;
10115 0 : void *argp1 = 0 ;
10116 : int res1 = 0 ;
10117 0 : PyObject * obj0 = 0 ;
10118 : char *result = 0 ;
10119 :
10120 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_header_get",&obj0)) SWIG_fail;
10121 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10122 0 : if (!SWIG_IsOK(res1)) {
10123 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_header_get" "', argument " "1"" of type '" "webObj *""'");
10124 : }
10125 0 : arg1 = (webObj *)(argp1);
10126 0 : result = (char *) ((arg1)->header);
10127 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10128 0 : return resultobj;
10129 0 : fail:
10130 : return NULL;
10131 : }
10132 :
10133 :
10134 0 : SWIGINTERN PyObject *_wrap_webObj_footer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10135 : PyObject *resultobj = 0;
10136 : webObj *arg1 = (webObj *) 0 ;
10137 : char *arg2 = (char *) 0 ;
10138 0 : void *argp1 = 0 ;
10139 : int res1 = 0 ;
10140 : int res2 ;
10141 0 : char *buf2 = 0 ;
10142 0 : int alloc2 = 0 ;
10143 0 : PyObject * obj0 = 0 ;
10144 0 : PyObject * obj1 = 0 ;
10145 :
10146 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_footer_set",&obj0,&obj1)) SWIG_fail;
10147 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10148 0 : if (!SWIG_IsOK(res1)) {
10149 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_footer_set" "', argument " "1"" of type '" "webObj *""'");
10150 : }
10151 0 : arg1 = (webObj *)(argp1);
10152 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10153 0 : if (!SWIG_IsOK(res2)) {
10154 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_footer_set" "', argument " "2"" of type '" "char *""'");
10155 : }
10156 0 : arg2 = (char *)(buf2);
10157 : {
10158 0 : if (arg1->footer) free((char*)arg1->footer);
10159 0 : if (arg2) {
10160 0 : arg1->footer = (char *) malloc(strlen(arg2)+1);
10161 : strcpy((char*)arg1->footer,arg2);
10162 : } else {
10163 0 : arg1->footer = 0;
10164 : }
10165 : }
10166 : resultobj = SWIG_Py_Void();
10167 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10168 : return resultobj;
10169 0 : fail:
10170 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10171 : return NULL;
10172 : }
10173 :
10174 :
10175 0 : SWIGINTERN PyObject *_wrap_webObj_footer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10176 : PyObject *resultobj = 0;
10177 : webObj *arg1 = (webObj *) 0 ;
10178 0 : void *argp1 = 0 ;
10179 : int res1 = 0 ;
10180 0 : PyObject * obj0 = 0 ;
10181 : char *result = 0 ;
10182 :
10183 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_footer_get",&obj0)) SWIG_fail;
10184 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10185 0 : if (!SWIG_IsOK(res1)) {
10186 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_footer_get" "', argument " "1"" of type '" "webObj *""'");
10187 : }
10188 0 : arg1 = (webObj *)(argp1);
10189 0 : result = (char *) ((arg1)->footer);
10190 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10191 0 : return resultobj;
10192 0 : fail:
10193 : return NULL;
10194 : }
10195 :
10196 :
10197 0 : SWIGINTERN PyObject *_wrap_webObj_empty_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10198 : PyObject *resultobj = 0;
10199 : webObj *arg1 = (webObj *) 0 ;
10200 : char *arg2 = (char *) 0 ;
10201 0 : void *argp1 = 0 ;
10202 : int res1 = 0 ;
10203 : int res2 ;
10204 0 : char *buf2 = 0 ;
10205 0 : int alloc2 = 0 ;
10206 0 : PyObject * obj0 = 0 ;
10207 0 : PyObject * obj1 = 0 ;
10208 :
10209 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_empty_set",&obj0,&obj1)) SWIG_fail;
10210 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10211 0 : if (!SWIG_IsOK(res1)) {
10212 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_empty_set" "', argument " "1"" of type '" "webObj *""'");
10213 : }
10214 0 : arg1 = (webObj *)(argp1);
10215 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10216 0 : if (!SWIG_IsOK(res2)) {
10217 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_empty_set" "', argument " "2"" of type '" "char *""'");
10218 : }
10219 0 : arg2 = (char *)(buf2);
10220 : {
10221 0 : if (arg1->empty) free((char*)arg1->empty);
10222 0 : if (arg2) {
10223 0 : arg1->empty = (char *) malloc(strlen(arg2)+1);
10224 : strcpy((char*)arg1->empty,arg2);
10225 : } else {
10226 0 : arg1->empty = 0;
10227 : }
10228 : }
10229 : resultobj = SWIG_Py_Void();
10230 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10231 : return resultobj;
10232 0 : fail:
10233 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10234 : return NULL;
10235 : }
10236 :
10237 :
10238 0 : SWIGINTERN PyObject *_wrap_webObj_empty_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10239 : PyObject *resultobj = 0;
10240 : webObj *arg1 = (webObj *) 0 ;
10241 0 : void *argp1 = 0 ;
10242 : int res1 = 0 ;
10243 0 : PyObject * obj0 = 0 ;
10244 : char *result = 0 ;
10245 :
10246 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_empty_get",&obj0)) SWIG_fail;
10247 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10248 0 : if (!SWIG_IsOK(res1)) {
10249 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_empty_get" "', argument " "1"" of type '" "webObj *""'");
10250 : }
10251 0 : arg1 = (webObj *)(argp1);
10252 0 : result = (char *) ((arg1)->empty);
10253 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10254 0 : return resultobj;
10255 0 : fail:
10256 : return NULL;
10257 : }
10258 :
10259 :
10260 0 : SWIGINTERN PyObject *_wrap_webObj_error_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10261 : PyObject *resultobj = 0;
10262 : webObj *arg1 = (webObj *) 0 ;
10263 : char *arg2 = (char *) 0 ;
10264 0 : void *argp1 = 0 ;
10265 : int res1 = 0 ;
10266 : int res2 ;
10267 0 : char *buf2 = 0 ;
10268 0 : int alloc2 = 0 ;
10269 0 : PyObject * obj0 = 0 ;
10270 0 : PyObject * obj1 = 0 ;
10271 :
10272 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_error_set",&obj0,&obj1)) SWIG_fail;
10273 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10274 0 : if (!SWIG_IsOK(res1)) {
10275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_error_set" "', argument " "1"" of type '" "webObj *""'");
10276 : }
10277 0 : arg1 = (webObj *)(argp1);
10278 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10279 0 : if (!SWIG_IsOK(res2)) {
10280 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_error_set" "', argument " "2"" of type '" "char *""'");
10281 : }
10282 0 : arg2 = (char *)(buf2);
10283 : {
10284 0 : if (arg1->error) free((char*)arg1->error);
10285 0 : if (arg2) {
10286 0 : arg1->error = (char *) malloc(strlen(arg2)+1);
10287 : strcpy((char*)arg1->error,arg2);
10288 : } else {
10289 0 : arg1->error = 0;
10290 : }
10291 : }
10292 : resultobj = SWIG_Py_Void();
10293 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10294 : return resultobj;
10295 0 : fail:
10296 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10297 : return NULL;
10298 : }
10299 :
10300 :
10301 0 : SWIGINTERN PyObject *_wrap_webObj_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10302 : PyObject *resultobj = 0;
10303 : webObj *arg1 = (webObj *) 0 ;
10304 0 : void *argp1 = 0 ;
10305 : int res1 = 0 ;
10306 0 : PyObject * obj0 = 0 ;
10307 : char *result = 0 ;
10308 :
10309 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_error_get",&obj0)) SWIG_fail;
10310 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10311 0 : if (!SWIG_IsOK(res1)) {
10312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_error_get" "', argument " "1"" of type '" "webObj *""'");
10313 : }
10314 0 : arg1 = (webObj *)(argp1);
10315 0 : result = (char *) ((arg1)->error);
10316 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10317 0 : return resultobj;
10318 0 : fail:
10319 : return NULL;
10320 : }
10321 :
10322 :
10323 0 : SWIGINTERN PyObject *_wrap_webObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10324 : PyObject *resultobj = 0;
10325 : webObj *arg1 = (webObj *) 0 ;
10326 : rectObj *arg2 = (rectObj *) 0 ;
10327 0 : void *argp1 = 0 ;
10328 : int res1 = 0 ;
10329 0 : void *argp2 = 0 ;
10330 : int res2 = 0 ;
10331 0 : PyObject * obj0 = 0 ;
10332 0 : PyObject * obj1 = 0 ;
10333 :
10334 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_extent_set",&obj0,&obj1)) SWIG_fail;
10335 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10336 0 : if (!SWIG_IsOK(res1)) {
10337 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_extent_set" "', argument " "1"" of type '" "webObj *""'");
10338 : }
10339 0 : arg1 = (webObj *)(argp1);
10340 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 | 0 );
10341 0 : if (!SWIG_IsOK(res2)) {
10342 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_extent_set" "', argument " "2"" of type '" "rectObj *""'");
10343 : }
10344 0 : arg2 = (rectObj *)(argp2);
10345 0 : if (arg1) (arg1)->extent = *arg2;
10346 : resultobj = SWIG_Py_Void();
10347 0 : return resultobj;
10348 0 : fail:
10349 : return NULL;
10350 : }
10351 :
10352 :
10353 0 : SWIGINTERN PyObject *_wrap_webObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10354 : PyObject *resultobj = 0;
10355 : webObj *arg1 = (webObj *) 0 ;
10356 0 : void *argp1 = 0 ;
10357 : int res1 = 0 ;
10358 0 : PyObject * obj0 = 0 ;
10359 : rectObj *result = 0 ;
10360 :
10361 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_extent_get",&obj0)) SWIG_fail;
10362 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10363 0 : if (!SWIG_IsOK(res1)) {
10364 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_extent_get" "', argument " "1"" of type '" "webObj *""'");
10365 : }
10366 0 : arg1 = (webObj *)(argp1);
10367 0 : result = (rectObj *)& ((arg1)->extent);
10368 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
10369 0 : return resultobj;
10370 0 : fail:
10371 : return NULL;
10372 : }
10373 :
10374 :
10375 0 : SWIGINTERN PyObject *_wrap_webObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10376 : PyObject *resultobj = 0;
10377 : webObj *arg1 = (webObj *) 0 ;
10378 : double arg2 ;
10379 0 : void *argp1 = 0 ;
10380 : int res1 = 0 ;
10381 : double val2 ;
10382 : int ecode2 = 0 ;
10383 0 : PyObject * obj0 = 0 ;
10384 0 : PyObject * obj1 = 0 ;
10385 :
10386 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
10387 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10388 0 : if (!SWIG_IsOK(res1)) {
10389 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_minscaledenom_set" "', argument " "1"" of type '" "webObj *""'");
10390 : }
10391 0 : arg1 = (webObj *)(argp1);
10392 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
10393 0 : if (!SWIG_IsOK(ecode2)) {
10394 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "webObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
10395 : }
10396 0 : arg2 = (double)(val2);
10397 0 : if (arg1) (arg1)->minscaledenom = arg2;
10398 : resultobj = SWIG_Py_Void();
10399 0 : return resultobj;
10400 0 : fail:
10401 : return NULL;
10402 : }
10403 :
10404 :
10405 0 : SWIGINTERN PyObject *_wrap_webObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10406 : PyObject *resultobj = 0;
10407 : webObj *arg1 = (webObj *) 0 ;
10408 0 : void *argp1 = 0 ;
10409 : int res1 = 0 ;
10410 0 : PyObject * obj0 = 0 ;
10411 : double result;
10412 :
10413 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_minscaledenom_get",&obj0)) SWIG_fail;
10414 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10415 0 : if (!SWIG_IsOK(res1)) {
10416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_minscaledenom_get" "', argument " "1"" of type '" "webObj *""'");
10417 : }
10418 0 : arg1 = (webObj *)(argp1);
10419 0 : result = (double) ((arg1)->minscaledenom);
10420 0 : resultobj = SWIG_From_double((double)(result));
10421 0 : return resultobj;
10422 0 : fail:
10423 : return NULL;
10424 : }
10425 :
10426 :
10427 0 : SWIGINTERN PyObject *_wrap_webObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10428 : PyObject *resultobj = 0;
10429 : webObj *arg1 = (webObj *) 0 ;
10430 : double arg2 ;
10431 0 : void *argp1 = 0 ;
10432 : int res1 = 0 ;
10433 : double val2 ;
10434 : int ecode2 = 0 ;
10435 0 : PyObject * obj0 = 0 ;
10436 0 : PyObject * obj1 = 0 ;
10437 :
10438 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
10439 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10440 0 : if (!SWIG_IsOK(res1)) {
10441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxscaledenom_set" "', argument " "1"" of type '" "webObj *""'");
10442 : }
10443 0 : arg1 = (webObj *)(argp1);
10444 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
10445 0 : if (!SWIG_IsOK(ecode2)) {
10446 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "webObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
10447 : }
10448 0 : arg2 = (double)(val2);
10449 0 : if (arg1) (arg1)->maxscaledenom = arg2;
10450 : resultobj = SWIG_Py_Void();
10451 0 : return resultobj;
10452 0 : fail:
10453 : return NULL;
10454 : }
10455 :
10456 :
10457 0 : SWIGINTERN PyObject *_wrap_webObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10458 : PyObject *resultobj = 0;
10459 : webObj *arg1 = (webObj *) 0 ;
10460 0 : void *argp1 = 0 ;
10461 : int res1 = 0 ;
10462 0 : PyObject * obj0 = 0 ;
10463 : double result;
10464 :
10465 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_maxscaledenom_get",&obj0)) SWIG_fail;
10466 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10467 0 : if (!SWIG_IsOK(res1)) {
10468 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxscaledenom_get" "', argument " "1"" of type '" "webObj *""'");
10469 : }
10470 0 : arg1 = (webObj *)(argp1);
10471 0 : result = (double) ((arg1)->maxscaledenom);
10472 0 : resultobj = SWIG_From_double((double)(result));
10473 0 : return resultobj;
10474 0 : fail:
10475 : return NULL;
10476 : }
10477 :
10478 :
10479 0 : SWIGINTERN PyObject *_wrap_webObj_mintemplate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10480 : PyObject *resultobj = 0;
10481 : webObj *arg1 = (webObj *) 0 ;
10482 : char *arg2 = (char *) 0 ;
10483 0 : void *argp1 = 0 ;
10484 : int res1 = 0 ;
10485 : int res2 ;
10486 0 : char *buf2 = 0 ;
10487 0 : int alloc2 = 0 ;
10488 0 : PyObject * obj0 = 0 ;
10489 0 : PyObject * obj1 = 0 ;
10490 :
10491 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_mintemplate_set",&obj0,&obj1)) SWIG_fail;
10492 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10493 0 : if (!SWIG_IsOK(res1)) {
10494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_mintemplate_set" "', argument " "1"" of type '" "webObj *""'");
10495 : }
10496 0 : arg1 = (webObj *)(argp1);
10497 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10498 0 : if (!SWIG_IsOK(res2)) {
10499 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_mintemplate_set" "', argument " "2"" of type '" "char *""'");
10500 : }
10501 0 : arg2 = (char *)(buf2);
10502 : {
10503 0 : if (arg1->mintemplate) free((char*)arg1->mintemplate);
10504 0 : if (arg2) {
10505 0 : arg1->mintemplate = (char *) malloc(strlen(arg2)+1);
10506 : strcpy((char*)arg1->mintemplate,arg2);
10507 : } else {
10508 0 : arg1->mintemplate = 0;
10509 : }
10510 : }
10511 : resultobj = SWIG_Py_Void();
10512 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10513 : return resultobj;
10514 0 : fail:
10515 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10516 : return NULL;
10517 : }
10518 :
10519 :
10520 0 : SWIGINTERN PyObject *_wrap_webObj_mintemplate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 : PyObject *resultobj = 0;
10522 : webObj *arg1 = (webObj *) 0 ;
10523 0 : void *argp1 = 0 ;
10524 : int res1 = 0 ;
10525 0 : PyObject * obj0 = 0 ;
10526 : char *result = 0 ;
10527 :
10528 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_mintemplate_get",&obj0)) SWIG_fail;
10529 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10530 0 : if (!SWIG_IsOK(res1)) {
10531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_mintemplate_get" "', argument " "1"" of type '" "webObj *""'");
10532 : }
10533 0 : arg1 = (webObj *)(argp1);
10534 0 : result = (char *) ((arg1)->mintemplate);
10535 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10536 0 : return resultobj;
10537 0 : fail:
10538 : return NULL;
10539 : }
10540 :
10541 :
10542 0 : SWIGINTERN PyObject *_wrap_webObj_maxtemplate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10543 : PyObject *resultobj = 0;
10544 : webObj *arg1 = (webObj *) 0 ;
10545 : char *arg2 = (char *) 0 ;
10546 0 : void *argp1 = 0 ;
10547 : int res1 = 0 ;
10548 : int res2 ;
10549 0 : char *buf2 = 0 ;
10550 0 : int alloc2 = 0 ;
10551 0 : PyObject * obj0 = 0 ;
10552 0 : PyObject * obj1 = 0 ;
10553 :
10554 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_maxtemplate_set",&obj0,&obj1)) SWIG_fail;
10555 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10556 0 : if (!SWIG_IsOK(res1)) {
10557 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxtemplate_set" "', argument " "1"" of type '" "webObj *""'");
10558 : }
10559 0 : arg1 = (webObj *)(argp1);
10560 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10561 0 : if (!SWIG_IsOK(res2)) {
10562 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_maxtemplate_set" "', argument " "2"" of type '" "char *""'");
10563 : }
10564 0 : arg2 = (char *)(buf2);
10565 : {
10566 0 : if (arg1->maxtemplate) free((char*)arg1->maxtemplate);
10567 0 : if (arg2) {
10568 0 : arg1->maxtemplate = (char *) malloc(strlen(arg2)+1);
10569 : strcpy((char*)arg1->maxtemplate,arg2);
10570 : } else {
10571 0 : arg1->maxtemplate = 0;
10572 : }
10573 : }
10574 : resultobj = SWIG_Py_Void();
10575 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10576 : return resultobj;
10577 0 : fail:
10578 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10579 : return NULL;
10580 : }
10581 :
10582 :
10583 0 : SWIGINTERN PyObject *_wrap_webObj_maxtemplate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10584 : PyObject *resultobj = 0;
10585 : webObj *arg1 = (webObj *) 0 ;
10586 0 : void *argp1 = 0 ;
10587 : int res1 = 0 ;
10588 0 : PyObject * obj0 = 0 ;
10589 : char *result = 0 ;
10590 :
10591 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_maxtemplate_get",&obj0)) SWIG_fail;
10592 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10593 0 : if (!SWIG_IsOK(res1)) {
10594 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_maxtemplate_get" "', argument " "1"" of type '" "webObj *""'");
10595 : }
10596 0 : arg1 = (webObj *)(argp1);
10597 0 : result = (char *) ((arg1)->maxtemplate);
10598 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10599 0 : return resultobj;
10600 0 : fail:
10601 : return NULL;
10602 : }
10603 :
10604 :
10605 0 : SWIGINTERN PyObject *_wrap_webObj_queryformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10606 : PyObject *resultobj = 0;
10607 : webObj *arg1 = (webObj *) 0 ;
10608 : char *arg2 = (char *) 0 ;
10609 0 : void *argp1 = 0 ;
10610 : int res1 = 0 ;
10611 : int res2 ;
10612 0 : char *buf2 = 0 ;
10613 0 : int alloc2 = 0 ;
10614 0 : PyObject * obj0 = 0 ;
10615 0 : PyObject * obj1 = 0 ;
10616 :
10617 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_queryformat_set",&obj0,&obj1)) SWIG_fail;
10618 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10619 0 : if (!SWIG_IsOK(res1)) {
10620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_queryformat_set" "', argument " "1"" of type '" "webObj *""'");
10621 : }
10622 0 : arg1 = (webObj *)(argp1);
10623 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10624 0 : if (!SWIG_IsOK(res2)) {
10625 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_queryformat_set" "', argument " "2"" of type '" "char *""'");
10626 : }
10627 0 : arg2 = (char *)(buf2);
10628 : {
10629 0 : if (arg1->queryformat) free((char*)arg1->queryformat);
10630 0 : if (arg2) {
10631 0 : arg1->queryformat = (char *) malloc(strlen(arg2)+1);
10632 : strcpy((char*)arg1->queryformat,arg2);
10633 : } else {
10634 0 : arg1->queryformat = 0;
10635 : }
10636 : }
10637 : resultobj = SWIG_Py_Void();
10638 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10639 : return resultobj;
10640 0 : fail:
10641 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10642 : return NULL;
10643 : }
10644 :
10645 :
10646 0 : SWIGINTERN PyObject *_wrap_webObj_queryformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10647 : PyObject *resultobj = 0;
10648 : webObj *arg1 = (webObj *) 0 ;
10649 0 : void *argp1 = 0 ;
10650 : int res1 = 0 ;
10651 0 : PyObject * obj0 = 0 ;
10652 : char *result = 0 ;
10653 :
10654 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_queryformat_get",&obj0)) SWIG_fail;
10655 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10656 0 : if (!SWIG_IsOK(res1)) {
10657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_queryformat_get" "', argument " "1"" of type '" "webObj *""'");
10658 : }
10659 0 : arg1 = (webObj *)(argp1);
10660 0 : result = (char *) ((arg1)->queryformat);
10661 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10662 0 : return resultobj;
10663 0 : fail:
10664 : return NULL;
10665 : }
10666 :
10667 :
10668 0 : SWIGINTERN PyObject *_wrap_webObj_legendformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10669 : PyObject *resultobj = 0;
10670 : webObj *arg1 = (webObj *) 0 ;
10671 : char *arg2 = (char *) 0 ;
10672 0 : void *argp1 = 0 ;
10673 : int res1 = 0 ;
10674 : int res2 ;
10675 0 : char *buf2 = 0 ;
10676 0 : int alloc2 = 0 ;
10677 0 : PyObject * obj0 = 0 ;
10678 0 : PyObject * obj1 = 0 ;
10679 :
10680 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_legendformat_set",&obj0,&obj1)) SWIG_fail;
10681 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10682 0 : if (!SWIG_IsOK(res1)) {
10683 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_legendformat_set" "', argument " "1"" of type '" "webObj *""'");
10684 : }
10685 0 : arg1 = (webObj *)(argp1);
10686 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10687 0 : if (!SWIG_IsOK(res2)) {
10688 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_legendformat_set" "', argument " "2"" of type '" "char *""'");
10689 : }
10690 0 : arg2 = (char *)(buf2);
10691 : {
10692 0 : if (arg1->legendformat) free((char*)arg1->legendformat);
10693 0 : if (arg2) {
10694 0 : arg1->legendformat = (char *) malloc(strlen(arg2)+1);
10695 : strcpy((char*)arg1->legendformat,arg2);
10696 : } else {
10697 0 : arg1->legendformat = 0;
10698 : }
10699 : }
10700 : resultobj = SWIG_Py_Void();
10701 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10702 : return resultobj;
10703 0 : fail:
10704 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10705 : return NULL;
10706 : }
10707 :
10708 :
10709 0 : SWIGINTERN PyObject *_wrap_webObj_legendformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10710 : PyObject *resultobj = 0;
10711 : webObj *arg1 = (webObj *) 0 ;
10712 0 : void *argp1 = 0 ;
10713 : int res1 = 0 ;
10714 0 : PyObject * obj0 = 0 ;
10715 : char *result = 0 ;
10716 :
10717 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_legendformat_get",&obj0)) SWIG_fail;
10718 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10719 0 : if (!SWIG_IsOK(res1)) {
10720 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_legendformat_get" "', argument " "1"" of type '" "webObj *""'");
10721 : }
10722 0 : arg1 = (webObj *)(argp1);
10723 0 : result = (char *) ((arg1)->legendformat);
10724 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10725 0 : return resultobj;
10726 0 : fail:
10727 : return NULL;
10728 : }
10729 :
10730 :
10731 0 : SWIGINTERN PyObject *_wrap_webObj_browseformat_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10732 : PyObject *resultobj = 0;
10733 : webObj *arg1 = (webObj *) 0 ;
10734 : char *arg2 = (char *) 0 ;
10735 0 : void *argp1 = 0 ;
10736 : int res1 = 0 ;
10737 : int res2 ;
10738 0 : char *buf2 = 0 ;
10739 0 : int alloc2 = 0 ;
10740 0 : PyObject * obj0 = 0 ;
10741 0 : PyObject * obj1 = 0 ;
10742 :
10743 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_browseformat_set",&obj0,&obj1)) SWIG_fail;
10744 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10745 0 : if (!SWIG_IsOK(res1)) {
10746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_browseformat_set" "', argument " "1"" of type '" "webObj *""'");
10747 : }
10748 0 : arg1 = (webObj *)(argp1);
10749 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10750 0 : if (!SWIG_IsOK(res2)) {
10751 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_browseformat_set" "', argument " "2"" of type '" "char *""'");
10752 : }
10753 0 : arg2 = (char *)(buf2);
10754 : {
10755 0 : if (arg1->browseformat) free((char*)arg1->browseformat);
10756 0 : if (arg2) {
10757 0 : arg1->browseformat = (char *) malloc(strlen(arg2)+1);
10758 : strcpy((char*)arg1->browseformat,arg2);
10759 : } else {
10760 0 : arg1->browseformat = 0;
10761 : }
10762 : }
10763 : resultobj = SWIG_Py_Void();
10764 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10765 : return resultobj;
10766 0 : fail:
10767 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10768 : return NULL;
10769 : }
10770 :
10771 :
10772 0 : SWIGINTERN PyObject *_wrap_webObj_browseformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10773 : PyObject *resultobj = 0;
10774 : webObj *arg1 = (webObj *) 0 ;
10775 0 : void *argp1 = 0 ;
10776 : int res1 = 0 ;
10777 0 : PyObject * obj0 = 0 ;
10778 : char *result = 0 ;
10779 :
10780 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_browseformat_get",&obj0)) SWIG_fail;
10781 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10782 0 : if (!SWIG_IsOK(res1)) {
10783 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_browseformat_get" "', argument " "1"" of type '" "webObj *""'");
10784 : }
10785 0 : arg1 = (webObj *)(argp1);
10786 0 : result = (char *) ((arg1)->browseformat);
10787 0 : resultobj = SWIG_FromCharPtr((const char *)result);
10788 0 : return resultobj;
10789 0 : fail:
10790 : return NULL;
10791 : }
10792 :
10793 :
10794 1 : SWIGINTERN PyObject *_wrap_webObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10795 : PyObject *resultobj = 0;
10796 : webObj *arg1 = (webObj *) 0 ;
10797 1 : void *argp1 = 0 ;
10798 : int res1 = 0 ;
10799 1 : PyObject * obj0 = 0 ;
10800 : hashTableObj *result = 0 ;
10801 :
10802 1 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_metadata_get",&obj0)) SWIG_fail;
10803 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10804 1 : if (!SWIG_IsOK(res1)) {
10805 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_metadata_get" "', argument " "1"" of type '" "webObj *""'");
10806 : }
10807 1 : arg1 = (webObj *)(argp1);
10808 1 : result = (hashTableObj *)& ((arg1)->metadata);
10809 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
10810 1 : return resultobj;
10811 0 : fail:
10812 : return NULL;
10813 : }
10814 :
10815 :
10816 0 : SWIGINTERN PyObject *_wrap_webObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10817 : PyObject *resultobj = 0;
10818 : webObj *arg1 = (webObj *) 0 ;
10819 0 : void *argp1 = 0 ;
10820 : int res1 = 0 ;
10821 0 : PyObject * obj0 = 0 ;
10822 : hashTableObj *result = 0 ;
10823 :
10824 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_validation_get",&obj0)) SWIG_fail;
10825 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10826 0 : if (!SWIG_IsOK(res1)) {
10827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_validation_get" "', argument " "1"" of type '" "webObj *""'");
10828 : }
10829 0 : arg1 = (webObj *)(argp1);
10830 0 : result = (hashTableObj *)& ((arg1)->validation);
10831 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
10832 0 : return resultobj;
10833 0 : fail:
10834 : return NULL;
10835 : }
10836 :
10837 :
10838 0 : SWIGINTERN PyObject *_wrap_new_webObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10839 : PyObject *resultobj = 0;
10840 : webObj *result = 0 ;
10841 :
10842 0 : if (!PyArg_ParseTuple(args,(char *)":new_webObj")) SWIG_fail;
10843 : {
10844 : result = (webObj *)new_webObj(); {
10845 0 : errorObj *ms_error = msGetErrorObj();
10846 :
10847 0 : switch(ms_error->code) {
10848 : case MS_NOERR:
10849 : break;
10850 0 : case MS_NOTFOUND:
10851 0 : msResetErrorList();
10852 0 : break;
10853 : case -1:
10854 : break;
10855 0 : case MS_IOERR:
10856 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
10857 0 : _raise_ms_exception();
10858 0 : msResetErrorList();
10859 0 : return NULL;
10860 : }
10861 : default:
10862 0 : _raise_ms_exception();
10863 0 : msResetErrorList();
10864 0 : return NULL;
10865 : }
10866 :
10867 : }
10868 : }
10869 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_webObj, SWIG_POINTER_NEW | 0 );
10870 0 : return resultobj;
10871 0 : fail:
10872 : return NULL;
10873 : }
10874 :
10875 :
10876 0 : SWIGINTERN PyObject *_wrap_delete_webObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10877 : PyObject *resultobj = 0;
10878 : webObj *arg1 = (webObj *) 0 ;
10879 0 : void *argp1 = 0 ;
10880 : int res1 = 0 ;
10881 0 : PyObject * obj0 = 0 ;
10882 :
10883 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_webObj",&obj0)) SWIG_fail;
10884 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, SWIG_POINTER_DISOWN | 0 );
10885 0 : if (!SWIG_IsOK(res1)) {
10886 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_webObj" "', argument " "1"" of type '" "webObj *""'");
10887 : }
10888 0 : arg1 = (webObj *)(argp1);
10889 : {
10890 : delete_webObj(arg1); {
10891 0 : errorObj *ms_error = msGetErrorObj();
10892 :
10893 0 : switch(ms_error->code) {
10894 : case MS_NOERR:
10895 : break;
10896 0 : case MS_NOTFOUND:
10897 0 : msResetErrorList();
10898 0 : break;
10899 : case -1:
10900 : break;
10901 0 : case MS_IOERR:
10902 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
10903 0 : _raise_ms_exception();
10904 0 : msResetErrorList();
10905 0 : return NULL;
10906 : }
10907 : default:
10908 0 : _raise_ms_exception();
10909 0 : msResetErrorList();
10910 0 : return NULL;
10911 : }
10912 :
10913 : }
10914 : }
10915 : resultobj = SWIG_Py_Void();
10916 0 : return resultobj;
10917 0 : fail:
10918 : return NULL;
10919 : }
10920 :
10921 :
10922 0 : SWIGINTERN PyObject *_wrap_webObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10923 : PyObject *resultobj = 0;
10924 : webObj *arg1 = (webObj *) 0 ;
10925 : char *arg2 = (char *) 0 ;
10926 0 : void *argp1 = 0 ;
10927 : int res1 = 0 ;
10928 : int res2 ;
10929 0 : char *buf2 = 0 ;
10930 0 : int alloc2 = 0 ;
10931 0 : PyObject * obj0 = 0 ;
10932 0 : PyObject * obj1 = 0 ;
10933 : int result;
10934 :
10935 0 : if (!PyArg_ParseTuple(args,(char *)"OO:webObj_updateFromString",&obj0,&obj1)) SWIG_fail;
10936 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10937 0 : if (!SWIG_IsOK(res1)) {
10938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_updateFromString" "', argument " "1"" of type '" "webObj *""'");
10939 : }
10940 0 : arg1 = (webObj *)(argp1);
10941 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10942 0 : if (!SWIG_IsOK(res2)) {
10943 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "webObj_updateFromString" "', argument " "2"" of type '" "char *""'");
10944 : }
10945 0 : arg2 = (char *)(buf2);
10946 : {
10947 : result = (int)webObj_updateFromString(arg1,arg2); {
10948 0 : errorObj *ms_error = msGetErrorObj();
10949 :
10950 0 : switch(ms_error->code) {
10951 : case MS_NOERR:
10952 : break;
10953 0 : case MS_NOTFOUND:
10954 0 : msResetErrorList();
10955 0 : break;
10956 : case -1:
10957 : break;
10958 0 : case MS_IOERR:
10959 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
10960 0 : _raise_ms_exception();
10961 0 : msResetErrorList();
10962 0 : return NULL;
10963 : }
10964 : default:
10965 0 : _raise_ms_exception();
10966 0 : msResetErrorList();
10967 0 : return NULL;
10968 : }
10969 :
10970 : }
10971 : }
10972 : resultobj = SWIG_From_int((int)(result));
10973 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10974 : return resultobj;
10975 0 : fail:
10976 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10977 : return NULL;
10978 : }
10979 :
10980 :
10981 0 : SWIGINTERN PyObject *_wrap_webObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10982 : PyObject *resultobj = 0;
10983 : webObj *arg1 = (webObj *) 0 ;
10984 0 : void *argp1 = 0 ;
10985 : int res1 = 0 ;
10986 0 : PyObject * obj0 = 0 ;
10987 : char *result = 0 ;
10988 :
10989 0 : if (!PyArg_ParseTuple(args,(char *)"O:webObj_convertToString",&obj0)) SWIG_fail;
10990 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_webObj, 0 | 0 );
10991 0 : if (!SWIG_IsOK(res1)) {
10992 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "webObj_convertToString" "', argument " "1"" of type '" "webObj *""'");
10993 : }
10994 0 : arg1 = (webObj *)(argp1);
10995 : {
10996 : result = (char *)webObj_convertToString(arg1); {
10997 0 : errorObj *ms_error = msGetErrorObj();
10998 :
10999 0 : switch(ms_error->code) {
11000 : case MS_NOERR:
11001 : break;
11002 0 : case MS_NOTFOUND:
11003 0 : msResetErrorList();
11004 0 : break;
11005 : case -1:
11006 : break;
11007 0 : case MS_IOERR:
11008 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
11009 0 : _raise_ms_exception();
11010 0 : msResetErrorList();
11011 0 : return NULL;
11012 : }
11013 : default:
11014 0 : _raise_ms_exception();
11015 0 : msResetErrorList();
11016 0 : return NULL;
11017 : }
11018 :
11019 : }
11020 : }
11021 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11022 0 : free((char*)result);
11023 0 : return resultobj;
11024 0 : fail:
11025 : return NULL;
11026 : }
11027 :
11028 :
11029 1 : SWIGINTERN PyObject *webObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11030 : PyObject *obj;
11031 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
11032 1 : SWIG_TypeNewClientData(SWIGTYPE_p_webObj, SWIG_NewClientData(obj));
11033 1 : return SWIG_Py_Void();
11034 : }
11035 :
11036 1 : SWIGINTERN PyObject *_wrap_styleObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11037 : PyObject *resultobj = 0;
11038 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11039 1 : void *argp1 = 0 ;
11040 : int res1 = 0 ;
11041 1 : PyObject * obj0 = 0 ;
11042 : int result;
11043 :
11044 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_refcount_get",&obj0)) SWIG_fail;
11045 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11046 1 : if (!SWIG_IsOK(res1)) {
11047 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_refcount_get" "', argument " "1"" of type '" "struct styleObj *""'");
11048 : }
11049 1 : arg1 = (struct styleObj *)(argp1);
11050 1 : result = (int) ((arg1)->refcount);
11051 : resultobj = SWIG_From_int((int)(result));
11052 1 : return resultobj;
11053 0 : fail:
11054 : return NULL;
11055 : }
11056 :
11057 :
11058 0 : SWIGINTERN PyObject *_wrap_styleObj_symbolname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11059 : PyObject *resultobj = 0;
11060 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11061 0 : void *argp1 = 0 ;
11062 : int res1 = 0 ;
11063 0 : PyObject * obj0 = 0 ;
11064 : char *result = 0 ;
11065 :
11066 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_symbolname_get",&obj0)) SWIG_fail;
11067 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11068 0 : if (!SWIG_IsOK(res1)) {
11069 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbolname_get" "', argument " "1"" of type '" "struct styleObj *""'");
11070 : }
11071 0 : arg1 = (struct styleObj *)(argp1);
11072 0 : result = (char *) ((arg1)->symbolname);
11073 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11074 0 : return resultobj;
11075 0 : fail:
11076 : return NULL;
11077 : }
11078 :
11079 :
11080 0 : SWIGINTERN PyObject *_wrap_styleObj_autoangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11081 : PyObject *resultobj = 0;
11082 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11083 : int arg2 ;
11084 0 : void *argp1 = 0 ;
11085 : int res1 = 0 ;
11086 : int val2 ;
11087 : int ecode2 = 0 ;
11088 0 : PyObject * obj0 = 0 ;
11089 0 : PyObject * obj1 = 0 ;
11090 :
11091 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_autoangle_set",&obj0,&obj1)) SWIG_fail;
11092 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11093 0 : if (!SWIG_IsOK(res1)) {
11094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_autoangle_set" "', argument " "1"" of type '" "struct styleObj *""'");
11095 : }
11096 0 : arg1 = (struct styleObj *)(argp1);
11097 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11098 0 : if (!SWIG_IsOK(ecode2)) {
11099 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_autoangle_set" "', argument " "2"" of type '" "int""'");
11100 : }
11101 : arg2 = (int)(val2);
11102 0 : if (arg1) (arg1)->autoangle = arg2;
11103 : resultobj = SWIG_Py_Void();
11104 0 : return resultobj;
11105 0 : fail:
11106 : return NULL;
11107 : }
11108 :
11109 :
11110 0 : SWIGINTERN PyObject *_wrap_styleObj_autoangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11111 : PyObject *resultobj = 0;
11112 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11113 0 : void *argp1 = 0 ;
11114 : int res1 = 0 ;
11115 0 : PyObject * obj0 = 0 ;
11116 : int result;
11117 :
11118 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_autoangle_get",&obj0)) SWIG_fail;
11119 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11120 0 : if (!SWIG_IsOK(res1)) {
11121 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_autoangle_get" "', argument " "1"" of type '" "struct styleObj *""'");
11122 : }
11123 0 : arg1 = (struct styleObj *)(argp1);
11124 0 : result = (int) ((arg1)->autoangle);
11125 : resultobj = SWIG_From_int((int)(result));
11126 0 : return resultobj;
11127 0 : fail:
11128 : return NULL;
11129 : }
11130 :
11131 :
11132 1 : SWIGINTERN PyObject *_wrap_styleObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11133 : PyObject *resultobj = 0;
11134 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11135 : colorObj *arg2 = (colorObj *) 0 ;
11136 1 : void *argp1 = 0 ;
11137 : int res1 = 0 ;
11138 1 : void *argp2 = 0 ;
11139 : int res2 = 0 ;
11140 1 : PyObject * obj0 = 0 ;
11141 1 : PyObject * obj1 = 0 ;
11142 :
11143 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_color_set",&obj0,&obj1)) SWIG_fail;
11144 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11145 1 : if (!SWIG_IsOK(res1)) {
11146 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_color_set" "', argument " "1"" of type '" "struct styleObj *""'");
11147 : }
11148 1 : arg1 = (struct styleObj *)(argp1);
11149 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
11150 1 : if (!SWIG_IsOK(res2)) {
11151 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_color_set" "', argument " "2"" of type '" "colorObj *""'");
11152 : }
11153 1 : arg2 = (colorObj *)(argp2);
11154 1 : if (arg1) (arg1)->color = *arg2;
11155 : resultobj = SWIG_Py_Void();
11156 1 : return resultobj;
11157 0 : fail:
11158 : return NULL;
11159 : }
11160 :
11161 :
11162 1 : SWIGINTERN PyObject *_wrap_styleObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11163 : PyObject *resultobj = 0;
11164 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11165 1 : void *argp1 = 0 ;
11166 : int res1 = 0 ;
11167 1 : PyObject * obj0 = 0 ;
11168 : colorObj *result = 0 ;
11169 :
11170 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_color_get",&obj0)) SWIG_fail;
11171 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11172 1 : if (!SWIG_IsOK(res1)) {
11173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_color_get" "', argument " "1"" of type '" "struct styleObj *""'");
11174 : }
11175 1 : arg1 = (struct styleObj *)(argp1);
11176 1 : result = (colorObj *)& ((arg1)->color);
11177 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
11178 1 : return resultobj;
11179 0 : fail:
11180 : return NULL;
11181 : }
11182 :
11183 :
11184 0 : SWIGINTERN PyObject *_wrap_styleObj_backgroundcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11185 : PyObject *resultobj = 0;
11186 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11187 : colorObj *arg2 = (colorObj *) 0 ;
11188 0 : void *argp1 = 0 ;
11189 : int res1 = 0 ;
11190 0 : void *argp2 = 0 ;
11191 : int res2 = 0 ;
11192 0 : PyObject * obj0 = 0 ;
11193 0 : PyObject * obj1 = 0 ;
11194 :
11195 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_backgroundcolor_set",&obj0,&obj1)) SWIG_fail;
11196 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11197 0 : if (!SWIG_IsOK(res1)) {
11198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_backgroundcolor_set" "', argument " "1"" of type '" "struct styleObj *""'");
11199 : }
11200 0 : arg1 = (struct styleObj *)(argp1);
11201 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
11202 0 : if (!SWIG_IsOK(res2)) {
11203 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_backgroundcolor_set" "', argument " "2"" of type '" "colorObj *""'");
11204 : }
11205 0 : arg2 = (colorObj *)(argp2);
11206 0 : if (arg1) (arg1)->backgroundcolor = *arg2;
11207 : resultobj = SWIG_Py_Void();
11208 0 : return resultobj;
11209 0 : fail:
11210 : return NULL;
11211 : }
11212 :
11213 :
11214 0 : SWIGINTERN PyObject *_wrap_styleObj_backgroundcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11215 : PyObject *resultobj = 0;
11216 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11217 0 : void *argp1 = 0 ;
11218 : int res1 = 0 ;
11219 0 : PyObject * obj0 = 0 ;
11220 : colorObj *result = 0 ;
11221 :
11222 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_backgroundcolor_get",&obj0)) SWIG_fail;
11223 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11224 0 : if (!SWIG_IsOK(res1)) {
11225 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_backgroundcolor_get" "', argument " "1"" of type '" "struct styleObj *""'");
11226 : }
11227 0 : arg1 = (struct styleObj *)(argp1);
11228 0 : result = (colorObj *)& ((arg1)->backgroundcolor);
11229 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
11230 0 : return resultobj;
11231 0 : fail:
11232 : return NULL;
11233 : }
11234 :
11235 :
11236 0 : SWIGINTERN PyObject *_wrap_styleObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11237 : PyObject *resultobj = 0;
11238 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11239 : colorObj *arg2 = (colorObj *) 0 ;
11240 0 : void *argp1 = 0 ;
11241 : int res1 = 0 ;
11242 0 : void *argp2 = 0 ;
11243 : int res2 = 0 ;
11244 0 : PyObject * obj0 = 0 ;
11245 0 : PyObject * obj1 = 0 ;
11246 :
11247 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
11248 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11249 0 : if (!SWIG_IsOK(res1)) {
11250 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinecolor_set" "', argument " "1"" of type '" "struct styleObj *""'");
11251 : }
11252 0 : arg1 = (struct styleObj *)(argp1);
11253 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
11254 0 : if (!SWIG_IsOK(res2)) {
11255 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'");
11256 : }
11257 0 : arg2 = (colorObj *)(argp2);
11258 0 : if (arg1) (arg1)->outlinecolor = *arg2;
11259 : resultobj = SWIG_Py_Void();
11260 0 : return resultobj;
11261 0 : fail:
11262 : return NULL;
11263 : }
11264 :
11265 :
11266 1 : SWIGINTERN PyObject *_wrap_styleObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11267 : PyObject *resultobj = 0;
11268 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11269 1 : void *argp1 = 0 ;
11270 : int res1 = 0 ;
11271 1 : PyObject * obj0 = 0 ;
11272 : colorObj *result = 0 ;
11273 :
11274 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_outlinecolor_get",&obj0)) SWIG_fail;
11275 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11276 1 : if (!SWIG_IsOK(res1)) {
11277 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinecolor_get" "', argument " "1"" of type '" "struct styleObj *""'");
11278 : }
11279 1 : arg1 = (struct styleObj *)(argp1);
11280 1 : result = (colorObj *)& ((arg1)->outlinecolor);
11281 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
11282 1 : return resultobj;
11283 0 : fail:
11284 : return NULL;
11285 : }
11286 :
11287 :
11288 0 : SWIGINTERN PyObject *_wrap_styleObj_opacity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11289 : PyObject *resultobj = 0;
11290 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11291 : int arg2 ;
11292 0 : void *argp1 = 0 ;
11293 : int res1 = 0 ;
11294 : int val2 ;
11295 : int ecode2 = 0 ;
11296 0 : PyObject * obj0 = 0 ;
11297 0 : PyObject * obj1 = 0 ;
11298 :
11299 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_opacity_set",&obj0,&obj1)) SWIG_fail;
11300 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11301 0 : if (!SWIG_IsOK(res1)) {
11302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_opacity_set" "', argument " "1"" of type '" "struct styleObj *""'");
11303 : }
11304 0 : arg1 = (struct styleObj *)(argp1);
11305 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11306 0 : if (!SWIG_IsOK(ecode2)) {
11307 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_opacity_set" "', argument " "2"" of type '" "int""'");
11308 : }
11309 : arg2 = (int)(val2);
11310 0 : if (arg1) (arg1)->opacity = arg2;
11311 : resultobj = SWIG_Py_Void();
11312 0 : return resultobj;
11313 0 : fail:
11314 : return NULL;
11315 : }
11316 :
11317 :
11318 0 : SWIGINTERN PyObject *_wrap_styleObj_opacity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11319 : PyObject *resultobj = 0;
11320 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11321 0 : void *argp1 = 0 ;
11322 : int res1 = 0 ;
11323 0 : PyObject * obj0 = 0 ;
11324 : int result;
11325 :
11326 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_opacity_get",&obj0)) SWIG_fail;
11327 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11328 0 : if (!SWIG_IsOK(res1)) {
11329 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_opacity_get" "', argument " "1"" of type '" "struct styleObj *""'");
11330 : }
11331 0 : arg1 = (struct styleObj *)(argp1);
11332 0 : result = (int) ((arg1)->opacity);
11333 : resultobj = SWIG_From_int((int)(result));
11334 0 : return resultobj;
11335 0 : fail:
11336 : return NULL;
11337 : }
11338 :
11339 :
11340 0 : SWIGINTERN PyObject *_wrap_styleObj_mincolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11341 : PyObject *resultobj = 0;
11342 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11343 : colorObj *arg2 = (colorObj *) 0 ;
11344 0 : void *argp1 = 0 ;
11345 : int res1 = 0 ;
11346 0 : void *argp2 = 0 ;
11347 : int res2 = 0 ;
11348 0 : PyObject * obj0 = 0 ;
11349 0 : PyObject * obj1 = 0 ;
11350 :
11351 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_mincolor_set",&obj0,&obj1)) SWIG_fail;
11352 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11353 0 : if (!SWIG_IsOK(res1)) {
11354 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_mincolor_set" "', argument " "1"" of type '" "struct styleObj *""'");
11355 : }
11356 0 : arg1 = (struct styleObj *)(argp1);
11357 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
11358 0 : if (!SWIG_IsOK(res2)) {
11359 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_mincolor_set" "', argument " "2"" of type '" "colorObj *""'");
11360 : }
11361 0 : arg2 = (colorObj *)(argp2);
11362 0 : if (arg1) (arg1)->mincolor = *arg2;
11363 : resultobj = SWIG_Py_Void();
11364 0 : return resultobj;
11365 0 : fail:
11366 : return NULL;
11367 : }
11368 :
11369 :
11370 0 : SWIGINTERN PyObject *_wrap_styleObj_mincolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11371 : PyObject *resultobj = 0;
11372 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11373 0 : void *argp1 = 0 ;
11374 : int res1 = 0 ;
11375 0 : PyObject * obj0 = 0 ;
11376 : colorObj *result = 0 ;
11377 :
11378 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_mincolor_get",&obj0)) SWIG_fail;
11379 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11380 0 : if (!SWIG_IsOK(res1)) {
11381 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_mincolor_get" "', argument " "1"" of type '" "struct styleObj *""'");
11382 : }
11383 0 : arg1 = (struct styleObj *)(argp1);
11384 0 : result = (colorObj *)& ((arg1)->mincolor);
11385 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
11386 0 : return resultobj;
11387 0 : fail:
11388 : return NULL;
11389 : }
11390 :
11391 :
11392 0 : SWIGINTERN PyObject *_wrap_styleObj_maxcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11393 : PyObject *resultobj = 0;
11394 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11395 : colorObj *arg2 = (colorObj *) 0 ;
11396 0 : void *argp1 = 0 ;
11397 : int res1 = 0 ;
11398 0 : void *argp2 = 0 ;
11399 : int res2 = 0 ;
11400 0 : PyObject * obj0 = 0 ;
11401 0 : PyObject * obj1 = 0 ;
11402 :
11403 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxcolor_set",&obj0,&obj1)) SWIG_fail;
11404 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11405 0 : if (!SWIG_IsOK(res1)) {
11406 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxcolor_set" "', argument " "1"" of type '" "struct styleObj *""'");
11407 : }
11408 0 : arg1 = (struct styleObj *)(argp1);
11409 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
11410 0 : if (!SWIG_IsOK(res2)) {
11411 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_maxcolor_set" "', argument " "2"" of type '" "colorObj *""'");
11412 : }
11413 0 : arg2 = (colorObj *)(argp2);
11414 0 : if (arg1) (arg1)->maxcolor = *arg2;
11415 : resultobj = SWIG_Py_Void();
11416 0 : return resultobj;
11417 0 : fail:
11418 : return NULL;
11419 : }
11420 :
11421 :
11422 0 : SWIGINTERN PyObject *_wrap_styleObj_maxcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11423 : PyObject *resultobj = 0;
11424 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11425 0 : void *argp1 = 0 ;
11426 : int res1 = 0 ;
11427 0 : PyObject * obj0 = 0 ;
11428 : colorObj *result = 0 ;
11429 :
11430 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxcolor_get",&obj0)) SWIG_fail;
11431 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11432 0 : if (!SWIG_IsOK(res1)) {
11433 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxcolor_get" "', argument " "1"" of type '" "struct styleObj *""'");
11434 : }
11435 0 : arg1 = (struct styleObj *)(argp1);
11436 0 : result = (colorObj *)& ((arg1)->maxcolor);
11437 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
11438 0 : return resultobj;
11439 0 : fail:
11440 : return NULL;
11441 : }
11442 :
11443 :
11444 0 : SWIGINTERN PyObject *_wrap_styleObj_minvalue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11445 : PyObject *resultobj = 0;
11446 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11447 : double arg2 ;
11448 0 : void *argp1 = 0 ;
11449 : int res1 = 0 ;
11450 : double val2 ;
11451 : int ecode2 = 0 ;
11452 0 : PyObject * obj0 = 0 ;
11453 0 : PyObject * obj1 = 0 ;
11454 :
11455 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minvalue_set",&obj0,&obj1)) SWIG_fail;
11456 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11457 0 : if (!SWIG_IsOK(res1)) {
11458 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minvalue_set" "', argument " "1"" of type '" "struct styleObj *""'");
11459 : }
11460 0 : arg1 = (struct styleObj *)(argp1);
11461 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11462 0 : if (!SWIG_IsOK(ecode2)) {
11463 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minvalue_set" "', argument " "2"" of type '" "double""'");
11464 : }
11465 0 : arg2 = (double)(val2);
11466 0 : if (arg1) (arg1)->minvalue = arg2;
11467 : resultobj = SWIG_Py_Void();
11468 0 : return resultobj;
11469 0 : fail:
11470 : return NULL;
11471 : }
11472 :
11473 :
11474 0 : SWIGINTERN PyObject *_wrap_styleObj_minvalue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11475 : PyObject *resultobj = 0;
11476 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11477 0 : void *argp1 = 0 ;
11478 : int res1 = 0 ;
11479 0 : PyObject * obj0 = 0 ;
11480 : double result;
11481 :
11482 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minvalue_get",&obj0)) SWIG_fail;
11483 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11484 0 : if (!SWIG_IsOK(res1)) {
11485 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minvalue_get" "', argument " "1"" of type '" "struct styleObj *""'");
11486 : }
11487 0 : arg1 = (struct styleObj *)(argp1);
11488 0 : result = (double) ((arg1)->minvalue);
11489 0 : resultobj = SWIG_From_double((double)(result));
11490 0 : return resultobj;
11491 0 : fail:
11492 : return NULL;
11493 : }
11494 :
11495 :
11496 0 : SWIGINTERN PyObject *_wrap_styleObj_maxvalue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11497 : PyObject *resultobj = 0;
11498 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11499 : double arg2 ;
11500 0 : void *argp1 = 0 ;
11501 : int res1 = 0 ;
11502 : double val2 ;
11503 : int ecode2 = 0 ;
11504 0 : PyObject * obj0 = 0 ;
11505 0 : PyObject * obj1 = 0 ;
11506 :
11507 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxvalue_set",&obj0,&obj1)) SWIG_fail;
11508 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11509 0 : if (!SWIG_IsOK(res1)) {
11510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxvalue_set" "', argument " "1"" of type '" "struct styleObj *""'");
11511 : }
11512 0 : arg1 = (struct styleObj *)(argp1);
11513 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11514 0 : if (!SWIG_IsOK(ecode2)) {
11515 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxvalue_set" "', argument " "2"" of type '" "double""'");
11516 : }
11517 0 : arg2 = (double)(val2);
11518 0 : if (arg1) (arg1)->maxvalue = arg2;
11519 : resultobj = SWIG_Py_Void();
11520 0 : return resultobj;
11521 0 : fail:
11522 : return NULL;
11523 : }
11524 :
11525 :
11526 0 : SWIGINTERN PyObject *_wrap_styleObj_maxvalue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11527 : PyObject *resultobj = 0;
11528 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11529 0 : void *argp1 = 0 ;
11530 : int res1 = 0 ;
11531 0 : PyObject * obj0 = 0 ;
11532 : double result;
11533 :
11534 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxvalue_get",&obj0)) SWIG_fail;
11535 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11536 0 : if (!SWIG_IsOK(res1)) {
11537 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxvalue_get" "', argument " "1"" of type '" "struct styleObj *""'");
11538 : }
11539 0 : arg1 = (struct styleObj *)(argp1);
11540 0 : result = (double) ((arg1)->maxvalue);
11541 0 : resultobj = SWIG_From_double((double)(result));
11542 0 : return resultobj;
11543 0 : fail:
11544 : return NULL;
11545 : }
11546 :
11547 :
11548 0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11549 : PyObject *resultobj = 0;
11550 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11551 : char *arg2 = (char *) 0 ;
11552 0 : void *argp1 = 0 ;
11553 : int res1 = 0 ;
11554 : int res2 ;
11555 0 : char *buf2 = 0 ;
11556 0 : int alloc2 = 0 ;
11557 0 : PyObject * obj0 = 0 ;
11558 0 : PyObject * obj1 = 0 ;
11559 :
11560 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_rangeitem_set",&obj0,&obj1)) SWIG_fail;
11561 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11562 0 : if (!SWIG_IsOK(res1)) {
11563 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitem_set" "', argument " "1"" of type '" "struct styleObj *""'");
11564 : }
11565 0 : arg1 = (struct styleObj *)(argp1);
11566 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
11567 0 : if (!SWIG_IsOK(res2)) {
11568 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_rangeitem_set" "', argument " "2"" of type '" "char *""'");
11569 : }
11570 0 : arg2 = (char *)(buf2);
11571 : {
11572 0 : if (arg1->rangeitem) free((char*)arg1->rangeitem);
11573 0 : if (arg2) {
11574 0 : arg1->rangeitem = (char *) malloc(strlen(arg2)+1);
11575 : strcpy((char*)arg1->rangeitem,arg2);
11576 : } else {
11577 0 : arg1->rangeitem = 0;
11578 : }
11579 : }
11580 : resultobj = SWIG_Py_Void();
11581 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11582 : return resultobj;
11583 0 : fail:
11584 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
11585 : return NULL;
11586 : }
11587 :
11588 :
11589 0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11590 : PyObject *resultobj = 0;
11591 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11592 0 : void *argp1 = 0 ;
11593 : int res1 = 0 ;
11594 0 : PyObject * obj0 = 0 ;
11595 : char *result = 0 ;
11596 :
11597 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_rangeitem_get",&obj0)) SWIG_fail;
11598 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11599 0 : if (!SWIG_IsOK(res1)) {
11600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitem_get" "', argument " "1"" of type '" "struct styleObj *""'");
11601 : }
11602 0 : arg1 = (struct styleObj *)(argp1);
11603 0 : result = (char *) ((arg1)->rangeitem);
11604 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11605 0 : return resultobj;
11606 0 : fail:
11607 : return NULL;
11608 : }
11609 :
11610 :
11611 0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitemindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11612 : PyObject *resultobj = 0;
11613 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11614 : int arg2 ;
11615 0 : void *argp1 = 0 ;
11616 : int res1 = 0 ;
11617 : int val2 ;
11618 : int ecode2 = 0 ;
11619 0 : PyObject * obj0 = 0 ;
11620 0 : PyObject * obj1 = 0 ;
11621 :
11622 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_rangeitemindex_set",&obj0,&obj1)) SWIG_fail;
11623 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11624 0 : if (!SWIG_IsOK(res1)) {
11625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitemindex_set" "', argument " "1"" of type '" "struct styleObj *""'");
11626 : }
11627 0 : arg1 = (struct styleObj *)(argp1);
11628 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11629 0 : if (!SWIG_IsOK(ecode2)) {
11630 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_rangeitemindex_set" "', argument " "2"" of type '" "int""'");
11631 : }
11632 : arg2 = (int)(val2);
11633 0 : if (arg1) (arg1)->rangeitemindex = arg2;
11634 : resultobj = SWIG_Py_Void();
11635 0 : return resultobj;
11636 0 : fail:
11637 : return NULL;
11638 : }
11639 :
11640 :
11641 0 : SWIGINTERN PyObject *_wrap_styleObj_rangeitemindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11642 : PyObject *resultobj = 0;
11643 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11644 0 : void *argp1 = 0 ;
11645 : int res1 = 0 ;
11646 0 : PyObject * obj0 = 0 ;
11647 : int result;
11648 :
11649 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_rangeitemindex_get",&obj0)) SWIG_fail;
11650 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11651 0 : if (!SWIG_IsOK(res1)) {
11652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_rangeitemindex_get" "', argument " "1"" of type '" "struct styleObj *""'");
11653 : }
11654 0 : arg1 = (struct styleObj *)(argp1);
11655 0 : result = (int) ((arg1)->rangeitemindex);
11656 : resultobj = SWIG_From_int((int)(result));
11657 0 : return resultobj;
11658 0 : fail:
11659 : return NULL;
11660 : }
11661 :
11662 :
11663 1 : SWIGINTERN PyObject *_wrap_styleObj_symbol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11664 : PyObject *resultobj = 0;
11665 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11666 : int arg2 ;
11667 1 : void *argp1 = 0 ;
11668 : int res1 = 0 ;
11669 : int val2 ;
11670 : int ecode2 = 0 ;
11671 1 : PyObject * obj0 = 0 ;
11672 1 : PyObject * obj1 = 0 ;
11673 :
11674 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_symbol_set",&obj0,&obj1)) SWIG_fail;
11675 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11676 1 : if (!SWIG_IsOK(res1)) {
11677 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbol_set" "', argument " "1"" of type '" "struct styleObj *""'");
11678 : }
11679 1 : arg1 = (struct styleObj *)(argp1);
11680 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11681 1 : if (!SWIG_IsOK(ecode2)) {
11682 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_symbol_set" "', argument " "2"" of type '" "int""'");
11683 : }
11684 : arg2 = (int)(val2);
11685 1 : if (arg1) (arg1)->symbol = arg2;
11686 : resultobj = SWIG_Py_Void();
11687 1 : return resultobj;
11688 0 : fail:
11689 : return NULL;
11690 : }
11691 :
11692 :
11693 1 : SWIGINTERN PyObject *_wrap_styleObj_symbol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 : PyObject *resultobj = 0;
11695 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11696 1 : void *argp1 = 0 ;
11697 : int res1 = 0 ;
11698 1 : PyObject * obj0 = 0 ;
11699 : int result;
11700 :
11701 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_symbol_get",&obj0)) SWIG_fail;
11702 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11703 1 : if (!SWIG_IsOK(res1)) {
11704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_symbol_get" "', argument " "1"" of type '" "struct styleObj *""'");
11705 : }
11706 1 : arg1 = (struct styleObj *)(argp1);
11707 1 : result = (int) ((arg1)->symbol);
11708 : resultobj = SWIG_From_int((int)(result));
11709 1 : return resultobj;
11710 0 : fail:
11711 : return NULL;
11712 : }
11713 :
11714 :
11715 1 : SWIGINTERN PyObject *_wrap_styleObj_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11716 : PyObject *resultobj = 0;
11717 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11718 : double arg2 ;
11719 1 : void *argp1 = 0 ;
11720 : int res1 = 0 ;
11721 : double val2 ;
11722 : int ecode2 = 0 ;
11723 1 : PyObject * obj0 = 0 ;
11724 1 : PyObject * obj1 = 0 ;
11725 :
11726 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_size_set",&obj0,&obj1)) SWIG_fail;
11727 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11728 1 : if (!SWIG_IsOK(res1)) {
11729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_size_set" "', argument " "1"" of type '" "struct styleObj *""'");
11730 : }
11731 1 : arg1 = (struct styleObj *)(argp1);
11732 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11733 1 : if (!SWIG_IsOK(ecode2)) {
11734 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_size_set" "', argument " "2"" of type '" "double""'");
11735 : }
11736 1 : arg2 = (double)(val2);
11737 1 : if (arg1) (arg1)->size = arg2;
11738 : resultobj = SWIG_Py_Void();
11739 1 : return resultobj;
11740 0 : fail:
11741 : return NULL;
11742 : }
11743 :
11744 :
11745 1 : SWIGINTERN PyObject *_wrap_styleObj_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11746 : PyObject *resultobj = 0;
11747 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11748 1 : void *argp1 = 0 ;
11749 : int res1 = 0 ;
11750 1 : PyObject * obj0 = 0 ;
11751 : double result;
11752 :
11753 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_size_get",&obj0)) SWIG_fail;
11754 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11755 1 : if (!SWIG_IsOK(res1)) {
11756 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_size_get" "', argument " "1"" of type '" "struct styleObj *""'");
11757 : }
11758 1 : arg1 = (struct styleObj *)(argp1);
11759 1 : result = (double) ((arg1)->size);
11760 1 : resultobj = SWIG_From_double((double)(result));
11761 1 : return resultobj;
11762 0 : fail:
11763 : return NULL;
11764 : }
11765 :
11766 :
11767 0 : SWIGINTERN PyObject *_wrap_styleObj_minsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11768 : PyObject *resultobj = 0;
11769 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11770 : double arg2 ;
11771 0 : void *argp1 = 0 ;
11772 : int res1 = 0 ;
11773 : double val2 ;
11774 : int ecode2 = 0 ;
11775 0 : PyObject * obj0 = 0 ;
11776 0 : PyObject * obj1 = 0 ;
11777 :
11778 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minsize_set",&obj0,&obj1)) SWIG_fail;
11779 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11780 0 : if (!SWIG_IsOK(res1)) {
11781 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minsize_set" "', argument " "1"" of type '" "struct styleObj *""'");
11782 : }
11783 0 : arg1 = (struct styleObj *)(argp1);
11784 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11785 0 : if (!SWIG_IsOK(ecode2)) {
11786 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minsize_set" "', argument " "2"" of type '" "double""'");
11787 : }
11788 0 : arg2 = (double)(val2);
11789 0 : if (arg1) (arg1)->minsize = arg2;
11790 : resultobj = SWIG_Py_Void();
11791 0 : return resultobj;
11792 0 : fail:
11793 : return NULL;
11794 : }
11795 :
11796 :
11797 0 : SWIGINTERN PyObject *_wrap_styleObj_minsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11798 : PyObject *resultobj = 0;
11799 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11800 0 : void *argp1 = 0 ;
11801 : int res1 = 0 ;
11802 0 : PyObject * obj0 = 0 ;
11803 : double result;
11804 :
11805 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minsize_get",&obj0)) SWIG_fail;
11806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11807 0 : if (!SWIG_IsOK(res1)) {
11808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minsize_get" "', argument " "1"" of type '" "struct styleObj *""'");
11809 : }
11810 0 : arg1 = (struct styleObj *)(argp1);
11811 0 : result = (double) ((arg1)->minsize);
11812 0 : resultobj = SWIG_From_double((double)(result));
11813 0 : return resultobj;
11814 0 : fail:
11815 : return NULL;
11816 : }
11817 :
11818 :
11819 0 : SWIGINTERN PyObject *_wrap_styleObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 : PyObject *resultobj = 0;
11821 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11822 : double arg2 ;
11823 0 : void *argp1 = 0 ;
11824 : int res1 = 0 ;
11825 : double val2 ;
11826 : int ecode2 = 0 ;
11827 0 : PyObject * obj0 = 0 ;
11828 0 : PyObject * obj1 = 0 ;
11829 :
11830 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
11831 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11832 0 : if (!SWIG_IsOK(res1)) {
11833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxsize_set" "', argument " "1"" of type '" "struct styleObj *""'");
11834 : }
11835 0 : arg1 = (struct styleObj *)(argp1);
11836 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11837 0 : if (!SWIG_IsOK(ecode2)) {
11838 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxsize_set" "', argument " "2"" of type '" "double""'");
11839 : }
11840 0 : arg2 = (double)(val2);
11841 0 : if (arg1) (arg1)->maxsize = arg2;
11842 : resultobj = SWIG_Py_Void();
11843 0 : return resultobj;
11844 0 : fail:
11845 : return NULL;
11846 : }
11847 :
11848 :
11849 0 : SWIGINTERN PyObject *_wrap_styleObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11850 : PyObject *resultobj = 0;
11851 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11852 0 : void *argp1 = 0 ;
11853 : int res1 = 0 ;
11854 0 : PyObject * obj0 = 0 ;
11855 : double result;
11856 :
11857 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxsize_get",&obj0)) SWIG_fail;
11858 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11859 0 : if (!SWIG_IsOK(res1)) {
11860 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxsize_get" "', argument " "1"" of type '" "struct styleObj *""'");
11861 : }
11862 0 : arg1 = (struct styleObj *)(argp1);
11863 0 : result = (double) ((arg1)->maxsize);
11864 0 : resultobj = SWIG_From_double((double)(result));
11865 0 : return resultobj;
11866 0 : fail:
11867 : return NULL;
11868 : }
11869 :
11870 :
11871 1 : SWIGINTERN PyObject *_wrap_styleObj_patternlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11872 : PyObject *resultobj = 0;
11873 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11874 1 : void *argp1 = 0 ;
11875 : int res1 = 0 ;
11876 1 : PyObject * obj0 = 0 ;
11877 : int result;
11878 :
11879 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_patternlength_get",&obj0)) SWIG_fail;
11880 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11881 1 : if (!SWIG_IsOK(res1)) {
11882 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_patternlength_get" "', argument " "1"" of type '" "struct styleObj *""'");
11883 : }
11884 1 : arg1 = (struct styleObj *)(argp1);
11885 1 : result = (int) ((arg1)->patternlength);
11886 : resultobj = SWIG_From_int((int)(result));
11887 1 : return resultobj;
11888 0 : fail:
11889 : return NULL;
11890 : }
11891 :
11892 :
11893 0 : SWIGINTERN PyObject *_wrap_styleObj_gap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11894 : PyObject *resultobj = 0;
11895 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11896 : double arg2 ;
11897 0 : void *argp1 = 0 ;
11898 : int res1 = 0 ;
11899 : double val2 ;
11900 : int ecode2 = 0 ;
11901 0 : PyObject * obj0 = 0 ;
11902 0 : PyObject * obj1 = 0 ;
11903 :
11904 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_gap_set",&obj0,&obj1)) SWIG_fail;
11905 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11906 0 : if (!SWIG_IsOK(res1)) {
11907 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_gap_set" "', argument " "1"" of type '" "struct styleObj *""'");
11908 : }
11909 0 : arg1 = (struct styleObj *)(argp1);
11910 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11911 0 : if (!SWIG_IsOK(ecode2)) {
11912 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_gap_set" "', argument " "2"" of type '" "double""'");
11913 : }
11914 0 : arg2 = (double)(val2);
11915 0 : if (arg1) (arg1)->gap = arg2;
11916 : resultobj = SWIG_Py_Void();
11917 0 : return resultobj;
11918 0 : fail:
11919 : return NULL;
11920 : }
11921 :
11922 :
11923 0 : SWIGINTERN PyObject *_wrap_styleObj_gap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11924 : PyObject *resultobj = 0;
11925 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11926 0 : void *argp1 = 0 ;
11927 : int res1 = 0 ;
11928 0 : PyObject * obj0 = 0 ;
11929 : double result;
11930 :
11931 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_gap_get",&obj0)) SWIG_fail;
11932 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11933 0 : if (!SWIG_IsOK(res1)) {
11934 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_gap_get" "', argument " "1"" of type '" "struct styleObj *""'");
11935 : }
11936 0 : arg1 = (struct styleObj *)(argp1);
11937 0 : result = (double) ((arg1)->gap);
11938 0 : resultobj = SWIG_From_double((double)(result));
11939 0 : return resultobj;
11940 0 : fail:
11941 : return NULL;
11942 : }
11943 :
11944 :
11945 0 : SWIGINTERN PyObject *_wrap_styleObj_initialgap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11946 : PyObject *resultobj = 0;
11947 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11948 : double arg2 ;
11949 0 : void *argp1 = 0 ;
11950 : int res1 = 0 ;
11951 : double val2 ;
11952 : int ecode2 = 0 ;
11953 0 : PyObject * obj0 = 0 ;
11954 0 : PyObject * obj1 = 0 ;
11955 :
11956 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_initialgap_set",&obj0,&obj1)) SWIG_fail;
11957 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11958 0 : if (!SWIG_IsOK(res1)) {
11959 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_initialgap_set" "', argument " "1"" of type '" "struct styleObj *""'");
11960 : }
11961 0 : arg1 = (struct styleObj *)(argp1);
11962 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
11963 0 : if (!SWIG_IsOK(ecode2)) {
11964 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_initialgap_set" "', argument " "2"" of type '" "double""'");
11965 : }
11966 0 : arg2 = (double)(val2);
11967 0 : if (arg1) (arg1)->initialgap = arg2;
11968 : resultobj = SWIG_Py_Void();
11969 0 : return resultobj;
11970 0 : fail:
11971 : return NULL;
11972 : }
11973 :
11974 :
11975 0 : SWIGINTERN PyObject *_wrap_styleObj_initialgap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11976 : PyObject *resultobj = 0;
11977 : struct styleObj *arg1 = (struct styleObj *) 0 ;
11978 0 : void *argp1 = 0 ;
11979 : int res1 = 0 ;
11980 0 : PyObject * obj0 = 0 ;
11981 : double result;
11982 :
11983 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_initialgap_get",&obj0)) SWIG_fail;
11984 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
11985 0 : if (!SWIG_IsOK(res1)) {
11986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_initialgap_get" "', argument " "1"" of type '" "struct styleObj *""'");
11987 : }
11988 0 : arg1 = (struct styleObj *)(argp1);
11989 0 : result = (double) ((arg1)->initialgap);
11990 0 : resultobj = SWIG_From_double((double)(result));
11991 0 : return resultobj;
11992 0 : fail:
11993 : return NULL;
11994 : }
11995 :
11996 :
11997 0 : SWIGINTERN PyObject *_wrap_styleObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11998 : PyObject *resultobj = 0;
11999 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12000 : int arg2 ;
12001 0 : void *argp1 = 0 ;
12002 : int res1 = 0 ;
12003 : int val2 ;
12004 : int ecode2 = 0 ;
12005 0 : PyObject * obj0 = 0 ;
12006 0 : PyObject * obj1 = 0 ;
12007 :
12008 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_position_set",&obj0,&obj1)) SWIG_fail;
12009 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12010 0 : if (!SWIG_IsOK(res1)) {
12011 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_position_set" "', argument " "1"" of type '" "struct styleObj *""'");
12012 : }
12013 0 : arg1 = (struct styleObj *)(argp1);
12014 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12015 0 : if (!SWIG_IsOK(ecode2)) {
12016 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_position_set" "', argument " "2"" of type '" "int""'");
12017 : }
12018 : arg2 = (int)(val2);
12019 0 : if (arg1) (arg1)->position = arg2;
12020 : resultobj = SWIG_Py_Void();
12021 0 : return resultobj;
12022 0 : fail:
12023 : return NULL;
12024 : }
12025 :
12026 :
12027 0 : SWIGINTERN PyObject *_wrap_styleObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12028 : PyObject *resultobj = 0;
12029 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12030 0 : void *argp1 = 0 ;
12031 : int res1 = 0 ;
12032 0 : PyObject * obj0 = 0 ;
12033 : int result;
12034 :
12035 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_position_get",&obj0)) SWIG_fail;
12036 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12037 0 : if (!SWIG_IsOK(res1)) {
12038 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_position_get" "', argument " "1"" of type '" "struct styleObj *""'");
12039 : }
12040 0 : arg1 = (struct styleObj *)(argp1);
12041 0 : result = (int) ((arg1)->position);
12042 : resultobj = SWIG_From_int((int)(result));
12043 0 : return resultobj;
12044 0 : fail:
12045 : return NULL;
12046 : }
12047 :
12048 :
12049 0 : SWIGINTERN PyObject *_wrap_styleObj_linecap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12050 : PyObject *resultobj = 0;
12051 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12052 : int arg2 ;
12053 0 : void *argp1 = 0 ;
12054 : int res1 = 0 ;
12055 : int val2 ;
12056 : int ecode2 = 0 ;
12057 0 : PyObject * obj0 = 0 ;
12058 0 : PyObject * obj1 = 0 ;
12059 :
12060 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linecap_set",&obj0,&obj1)) SWIG_fail;
12061 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12062 0 : if (!SWIG_IsOK(res1)) {
12063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linecap_set" "', argument " "1"" of type '" "struct styleObj *""'");
12064 : }
12065 0 : arg1 = (struct styleObj *)(argp1);
12066 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12067 0 : if (!SWIG_IsOK(ecode2)) {
12068 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linecap_set" "', argument " "2"" of type '" "int""'");
12069 : }
12070 : arg2 = (int)(val2);
12071 0 : if (arg1) (arg1)->linecap = arg2;
12072 : resultobj = SWIG_Py_Void();
12073 0 : return resultobj;
12074 0 : fail:
12075 : return NULL;
12076 : }
12077 :
12078 :
12079 0 : SWIGINTERN PyObject *_wrap_styleObj_linecap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12080 : PyObject *resultobj = 0;
12081 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12082 0 : void *argp1 = 0 ;
12083 : int res1 = 0 ;
12084 0 : PyObject * obj0 = 0 ;
12085 : int result;
12086 :
12087 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linecap_get",&obj0)) SWIG_fail;
12088 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12089 0 : if (!SWIG_IsOK(res1)) {
12090 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linecap_get" "', argument " "1"" of type '" "struct styleObj *""'");
12091 : }
12092 0 : arg1 = (struct styleObj *)(argp1);
12093 0 : result = (int) ((arg1)->linecap);
12094 : resultobj = SWIG_From_int((int)(result));
12095 0 : return resultobj;
12096 0 : fail:
12097 : return NULL;
12098 : }
12099 :
12100 :
12101 0 : SWIGINTERN PyObject *_wrap_styleObj_linejoin_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 : PyObject *resultobj = 0;
12103 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12104 : int arg2 ;
12105 0 : void *argp1 = 0 ;
12106 : int res1 = 0 ;
12107 : int val2 ;
12108 : int ecode2 = 0 ;
12109 0 : PyObject * obj0 = 0 ;
12110 0 : PyObject * obj1 = 0 ;
12111 :
12112 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linejoin_set",&obj0,&obj1)) SWIG_fail;
12113 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12114 0 : if (!SWIG_IsOK(res1)) {
12115 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoin_set" "', argument " "1"" of type '" "struct styleObj *""'");
12116 : }
12117 0 : arg1 = (struct styleObj *)(argp1);
12118 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12119 0 : if (!SWIG_IsOK(ecode2)) {
12120 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linejoin_set" "', argument " "2"" of type '" "int""'");
12121 : }
12122 : arg2 = (int)(val2);
12123 0 : if (arg1) (arg1)->linejoin = arg2;
12124 : resultobj = SWIG_Py_Void();
12125 0 : return resultobj;
12126 0 : fail:
12127 : return NULL;
12128 : }
12129 :
12130 :
12131 0 : SWIGINTERN PyObject *_wrap_styleObj_linejoin_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12132 : PyObject *resultobj = 0;
12133 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12134 0 : void *argp1 = 0 ;
12135 : int res1 = 0 ;
12136 0 : PyObject * obj0 = 0 ;
12137 : int result;
12138 :
12139 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linejoin_get",&obj0)) SWIG_fail;
12140 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12141 0 : if (!SWIG_IsOK(res1)) {
12142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoin_get" "', argument " "1"" of type '" "struct styleObj *""'");
12143 : }
12144 0 : arg1 = (struct styleObj *)(argp1);
12145 0 : result = (int) ((arg1)->linejoin);
12146 : resultobj = SWIG_From_int((int)(result));
12147 0 : return resultobj;
12148 0 : fail:
12149 : return NULL;
12150 : }
12151 :
12152 :
12153 0 : SWIGINTERN PyObject *_wrap_styleObj_linejoinmaxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12154 : PyObject *resultobj = 0;
12155 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12156 : double arg2 ;
12157 0 : void *argp1 = 0 ;
12158 : int res1 = 0 ;
12159 : double val2 ;
12160 : int ecode2 = 0 ;
12161 0 : PyObject * obj0 = 0 ;
12162 0 : PyObject * obj1 = 0 ;
12163 :
12164 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_linejoinmaxsize_set",&obj0,&obj1)) SWIG_fail;
12165 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12166 0 : if (!SWIG_IsOK(res1)) {
12167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoinmaxsize_set" "', argument " "1"" of type '" "struct styleObj *""'");
12168 : }
12169 0 : arg1 = (struct styleObj *)(argp1);
12170 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12171 0 : if (!SWIG_IsOK(ecode2)) {
12172 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_linejoinmaxsize_set" "', argument " "2"" of type '" "double""'");
12173 : }
12174 0 : arg2 = (double)(val2);
12175 0 : if (arg1) (arg1)->linejoinmaxsize = arg2;
12176 : resultobj = SWIG_Py_Void();
12177 0 : return resultobj;
12178 0 : fail:
12179 : return NULL;
12180 : }
12181 :
12182 :
12183 0 : SWIGINTERN PyObject *_wrap_styleObj_linejoinmaxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12184 : PyObject *resultobj = 0;
12185 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12186 0 : void *argp1 = 0 ;
12187 : int res1 = 0 ;
12188 0 : PyObject * obj0 = 0 ;
12189 : double result;
12190 :
12191 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_linejoinmaxsize_get",&obj0)) SWIG_fail;
12192 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12193 0 : if (!SWIG_IsOK(res1)) {
12194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_linejoinmaxsize_get" "', argument " "1"" of type '" "struct styleObj *""'");
12195 : }
12196 0 : arg1 = (struct styleObj *)(argp1);
12197 0 : result = (double) ((arg1)->linejoinmaxsize);
12198 0 : resultobj = SWIG_From_double((double)(result));
12199 0 : return resultobj;
12200 0 : fail:
12201 : return NULL;
12202 : }
12203 :
12204 :
12205 0 : SWIGINTERN PyObject *_wrap_styleObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12206 : PyObject *resultobj = 0;
12207 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12208 : double arg2 ;
12209 0 : void *argp1 = 0 ;
12210 : int res1 = 0 ;
12211 : double val2 ;
12212 : int ecode2 = 0 ;
12213 0 : PyObject * obj0 = 0 ;
12214 0 : PyObject * obj1 = 0 ;
12215 :
12216 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_width_set",&obj0,&obj1)) SWIG_fail;
12217 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12218 0 : if (!SWIG_IsOK(res1)) {
12219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_width_set" "', argument " "1"" of type '" "struct styleObj *""'");
12220 : }
12221 0 : arg1 = (struct styleObj *)(argp1);
12222 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12223 0 : if (!SWIG_IsOK(ecode2)) {
12224 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_width_set" "', argument " "2"" of type '" "double""'");
12225 : }
12226 0 : arg2 = (double)(val2);
12227 0 : if (arg1) (arg1)->width = arg2;
12228 : resultobj = SWIG_Py_Void();
12229 0 : return resultobj;
12230 0 : fail:
12231 : return NULL;
12232 : }
12233 :
12234 :
12235 0 : SWIGINTERN PyObject *_wrap_styleObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12236 : PyObject *resultobj = 0;
12237 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12238 0 : void *argp1 = 0 ;
12239 : int res1 = 0 ;
12240 0 : PyObject * obj0 = 0 ;
12241 : double result;
12242 :
12243 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_width_get",&obj0)) SWIG_fail;
12244 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12245 0 : if (!SWIG_IsOK(res1)) {
12246 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_width_get" "', argument " "1"" of type '" "struct styleObj *""'");
12247 : }
12248 0 : arg1 = (struct styleObj *)(argp1);
12249 0 : result = (double) ((arg1)->width);
12250 0 : resultobj = SWIG_From_double((double)(result));
12251 0 : return resultobj;
12252 0 : fail:
12253 : return NULL;
12254 : }
12255 :
12256 :
12257 0 : SWIGINTERN PyObject *_wrap_styleObj_outlinewidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12258 : PyObject *resultobj = 0;
12259 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12260 : double arg2 ;
12261 0 : void *argp1 = 0 ;
12262 : int res1 = 0 ;
12263 : double val2 ;
12264 : int ecode2 = 0 ;
12265 0 : PyObject * obj0 = 0 ;
12266 0 : PyObject * obj1 = 0 ;
12267 :
12268 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_outlinewidth_set",&obj0,&obj1)) SWIG_fail;
12269 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12270 0 : if (!SWIG_IsOK(res1)) {
12271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinewidth_set" "', argument " "1"" of type '" "struct styleObj *""'");
12272 : }
12273 0 : arg1 = (struct styleObj *)(argp1);
12274 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12275 0 : if (!SWIG_IsOK(ecode2)) {
12276 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_outlinewidth_set" "', argument " "2"" of type '" "double""'");
12277 : }
12278 0 : arg2 = (double)(val2);
12279 0 : if (arg1) (arg1)->outlinewidth = arg2;
12280 : resultobj = SWIG_Py_Void();
12281 0 : return resultobj;
12282 0 : fail:
12283 : return NULL;
12284 : }
12285 :
12286 :
12287 0 : SWIGINTERN PyObject *_wrap_styleObj_outlinewidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12288 : PyObject *resultobj = 0;
12289 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12290 0 : void *argp1 = 0 ;
12291 : int res1 = 0 ;
12292 0 : PyObject * obj0 = 0 ;
12293 : double result;
12294 :
12295 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_outlinewidth_get",&obj0)) SWIG_fail;
12296 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12297 0 : if (!SWIG_IsOK(res1)) {
12298 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_outlinewidth_get" "', argument " "1"" of type '" "struct styleObj *""'");
12299 : }
12300 0 : arg1 = (struct styleObj *)(argp1);
12301 0 : result = (double) ((arg1)->outlinewidth);
12302 0 : resultobj = SWIG_From_double((double)(result));
12303 0 : return resultobj;
12304 0 : fail:
12305 : return NULL;
12306 : }
12307 :
12308 :
12309 0 : SWIGINTERN PyObject *_wrap_styleObj_minwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12310 : PyObject *resultobj = 0;
12311 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12312 : double arg2 ;
12313 0 : void *argp1 = 0 ;
12314 : int res1 = 0 ;
12315 : double val2 ;
12316 : int ecode2 = 0 ;
12317 0 : PyObject * obj0 = 0 ;
12318 0 : PyObject * obj1 = 0 ;
12319 :
12320 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minwidth_set",&obj0,&obj1)) SWIG_fail;
12321 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12322 0 : if (!SWIG_IsOK(res1)) {
12323 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minwidth_set" "', argument " "1"" of type '" "struct styleObj *""'");
12324 : }
12325 0 : arg1 = (struct styleObj *)(argp1);
12326 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12327 0 : if (!SWIG_IsOK(ecode2)) {
12328 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minwidth_set" "', argument " "2"" of type '" "double""'");
12329 : }
12330 0 : arg2 = (double)(val2);
12331 0 : if (arg1) (arg1)->minwidth = arg2;
12332 : resultobj = SWIG_Py_Void();
12333 0 : return resultobj;
12334 0 : fail:
12335 : return NULL;
12336 : }
12337 :
12338 :
12339 0 : SWIGINTERN PyObject *_wrap_styleObj_minwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12340 : PyObject *resultobj = 0;
12341 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12342 0 : void *argp1 = 0 ;
12343 : int res1 = 0 ;
12344 0 : PyObject * obj0 = 0 ;
12345 : double result;
12346 :
12347 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minwidth_get",&obj0)) SWIG_fail;
12348 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12349 0 : if (!SWIG_IsOK(res1)) {
12350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minwidth_get" "', argument " "1"" of type '" "struct styleObj *""'");
12351 : }
12352 0 : arg1 = (struct styleObj *)(argp1);
12353 0 : result = (double) ((arg1)->minwidth);
12354 0 : resultobj = SWIG_From_double((double)(result));
12355 0 : return resultobj;
12356 0 : fail:
12357 : return NULL;
12358 : }
12359 :
12360 :
12361 0 : SWIGINTERN PyObject *_wrap_styleObj_maxwidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12362 : PyObject *resultobj = 0;
12363 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12364 : double arg2 ;
12365 0 : void *argp1 = 0 ;
12366 : int res1 = 0 ;
12367 : double val2 ;
12368 : int ecode2 = 0 ;
12369 0 : PyObject * obj0 = 0 ;
12370 0 : PyObject * obj1 = 0 ;
12371 :
12372 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxwidth_set",&obj0,&obj1)) SWIG_fail;
12373 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12374 0 : if (!SWIG_IsOK(res1)) {
12375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxwidth_set" "', argument " "1"" of type '" "struct styleObj *""'");
12376 : }
12377 0 : arg1 = (struct styleObj *)(argp1);
12378 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12379 0 : if (!SWIG_IsOK(ecode2)) {
12380 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxwidth_set" "', argument " "2"" of type '" "double""'");
12381 : }
12382 0 : arg2 = (double)(val2);
12383 0 : if (arg1) (arg1)->maxwidth = arg2;
12384 : resultobj = SWIG_Py_Void();
12385 0 : return resultobj;
12386 0 : fail:
12387 : return NULL;
12388 : }
12389 :
12390 :
12391 0 : SWIGINTERN PyObject *_wrap_styleObj_maxwidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12392 : PyObject *resultobj = 0;
12393 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12394 0 : void *argp1 = 0 ;
12395 : int res1 = 0 ;
12396 0 : PyObject * obj0 = 0 ;
12397 : double result;
12398 :
12399 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxwidth_get",&obj0)) SWIG_fail;
12400 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12401 0 : if (!SWIG_IsOK(res1)) {
12402 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxwidth_get" "', argument " "1"" of type '" "struct styleObj *""'");
12403 : }
12404 0 : arg1 = (struct styleObj *)(argp1);
12405 0 : result = (double) ((arg1)->maxwidth);
12406 0 : resultobj = SWIG_From_double((double)(result));
12407 0 : return resultobj;
12408 0 : fail:
12409 : return NULL;
12410 : }
12411 :
12412 :
12413 0 : SWIGINTERN PyObject *_wrap_styleObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12414 : PyObject *resultobj = 0;
12415 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12416 : double arg2 ;
12417 0 : void *argp1 = 0 ;
12418 : int res1 = 0 ;
12419 : double val2 ;
12420 : int ecode2 = 0 ;
12421 0 : PyObject * obj0 = 0 ;
12422 0 : PyObject * obj1 = 0 ;
12423 :
12424 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
12425 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12426 0 : if (!SWIG_IsOK(res1)) {
12427 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsetx_set" "', argument " "1"" of type '" "struct styleObj *""'");
12428 : }
12429 0 : arg1 = (struct styleObj *)(argp1);
12430 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12431 0 : if (!SWIG_IsOK(ecode2)) {
12432 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_offsetx_set" "', argument " "2"" of type '" "double""'");
12433 : }
12434 0 : arg2 = (double)(val2);
12435 0 : if (arg1) (arg1)->offsetx = arg2;
12436 : resultobj = SWIG_Py_Void();
12437 0 : return resultobj;
12438 0 : fail:
12439 : return NULL;
12440 : }
12441 :
12442 :
12443 1 : SWIGINTERN PyObject *_wrap_styleObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12444 : PyObject *resultobj = 0;
12445 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12446 1 : void *argp1 = 0 ;
12447 : int res1 = 0 ;
12448 1 : PyObject * obj0 = 0 ;
12449 : double result;
12450 :
12451 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_offsetx_get",&obj0)) SWIG_fail;
12452 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12453 1 : if (!SWIG_IsOK(res1)) {
12454 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsetx_get" "', argument " "1"" of type '" "struct styleObj *""'");
12455 : }
12456 1 : arg1 = (struct styleObj *)(argp1);
12457 1 : result = (double) ((arg1)->offsetx);
12458 1 : resultobj = SWIG_From_double((double)(result));
12459 1 : return resultobj;
12460 0 : fail:
12461 : return NULL;
12462 : }
12463 :
12464 :
12465 0 : SWIGINTERN PyObject *_wrap_styleObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12466 : PyObject *resultobj = 0;
12467 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12468 : double arg2 ;
12469 0 : void *argp1 = 0 ;
12470 : int res1 = 0 ;
12471 : double val2 ;
12472 : int ecode2 = 0 ;
12473 0 : PyObject * obj0 = 0 ;
12474 0 : PyObject * obj1 = 0 ;
12475 :
12476 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_offsety_set",&obj0,&obj1)) SWIG_fail;
12477 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12478 0 : if (!SWIG_IsOK(res1)) {
12479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsety_set" "', argument " "1"" of type '" "struct styleObj *""'");
12480 : }
12481 0 : arg1 = (struct styleObj *)(argp1);
12482 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12483 0 : if (!SWIG_IsOK(ecode2)) {
12484 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_offsety_set" "', argument " "2"" of type '" "double""'");
12485 : }
12486 0 : arg2 = (double)(val2);
12487 0 : if (arg1) (arg1)->offsety = arg2;
12488 : resultobj = SWIG_Py_Void();
12489 0 : return resultobj;
12490 0 : fail:
12491 : return NULL;
12492 : }
12493 :
12494 :
12495 1 : SWIGINTERN PyObject *_wrap_styleObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12496 : PyObject *resultobj = 0;
12497 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12498 1 : void *argp1 = 0 ;
12499 : int res1 = 0 ;
12500 1 : PyObject * obj0 = 0 ;
12501 : double result;
12502 :
12503 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_offsety_get",&obj0)) SWIG_fail;
12504 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12505 1 : if (!SWIG_IsOK(res1)) {
12506 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_offsety_get" "', argument " "1"" of type '" "struct styleObj *""'");
12507 : }
12508 1 : arg1 = (struct styleObj *)(argp1);
12509 1 : result = (double) ((arg1)->offsety);
12510 1 : resultobj = SWIG_From_double((double)(result));
12511 1 : return resultobj;
12512 0 : fail:
12513 : return NULL;
12514 : }
12515 :
12516 :
12517 0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetpixel_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12518 : PyObject *resultobj = 0;
12519 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12520 : double arg2 ;
12521 0 : void *argp1 = 0 ;
12522 : int res1 = 0 ;
12523 : double val2 ;
12524 : int ecode2 = 0 ;
12525 0 : PyObject * obj0 = 0 ;
12526 0 : PyObject * obj1 = 0 ;
12527 :
12528 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_polaroffsetpixel_set",&obj0,&obj1)) SWIG_fail;
12529 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12530 0 : if (!SWIG_IsOK(res1)) {
12531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetpixel_set" "', argument " "1"" of type '" "struct styleObj *""'");
12532 : }
12533 0 : arg1 = (struct styleObj *)(argp1);
12534 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12535 0 : if (!SWIG_IsOK(ecode2)) {
12536 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_polaroffsetpixel_set" "', argument " "2"" of type '" "double""'");
12537 : }
12538 0 : arg2 = (double)(val2);
12539 0 : if (arg1) (arg1)->polaroffsetpixel = arg2;
12540 : resultobj = SWIG_Py_Void();
12541 0 : return resultobj;
12542 0 : fail:
12543 : return NULL;
12544 : }
12545 :
12546 :
12547 0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetpixel_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12548 : PyObject *resultobj = 0;
12549 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12550 0 : void *argp1 = 0 ;
12551 : int res1 = 0 ;
12552 0 : PyObject * obj0 = 0 ;
12553 : double result;
12554 :
12555 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_polaroffsetpixel_get",&obj0)) SWIG_fail;
12556 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12557 0 : if (!SWIG_IsOK(res1)) {
12558 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetpixel_get" "', argument " "1"" of type '" "struct styleObj *""'");
12559 : }
12560 0 : arg1 = (struct styleObj *)(argp1);
12561 0 : result = (double) ((arg1)->polaroffsetpixel);
12562 0 : resultobj = SWIG_From_double((double)(result));
12563 0 : return resultobj;
12564 0 : fail:
12565 : return NULL;
12566 : }
12567 :
12568 :
12569 0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12570 : PyObject *resultobj = 0;
12571 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12572 : double arg2 ;
12573 0 : void *argp1 = 0 ;
12574 : int res1 = 0 ;
12575 : double val2 ;
12576 : int ecode2 = 0 ;
12577 0 : PyObject * obj0 = 0 ;
12578 0 : PyObject * obj1 = 0 ;
12579 :
12580 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_polaroffsetangle_set",&obj0,&obj1)) SWIG_fail;
12581 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12582 0 : if (!SWIG_IsOK(res1)) {
12583 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetangle_set" "', argument " "1"" of type '" "struct styleObj *""'");
12584 : }
12585 0 : arg1 = (struct styleObj *)(argp1);
12586 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12587 0 : if (!SWIG_IsOK(ecode2)) {
12588 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_polaroffsetangle_set" "', argument " "2"" of type '" "double""'");
12589 : }
12590 0 : arg2 = (double)(val2);
12591 0 : if (arg1) (arg1)->polaroffsetangle = arg2;
12592 : resultobj = SWIG_Py_Void();
12593 0 : return resultobj;
12594 0 : fail:
12595 : return NULL;
12596 : }
12597 :
12598 :
12599 0 : SWIGINTERN PyObject *_wrap_styleObj_polaroffsetangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12600 : PyObject *resultobj = 0;
12601 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12602 0 : void *argp1 = 0 ;
12603 : int res1 = 0 ;
12604 0 : PyObject * obj0 = 0 ;
12605 : double result;
12606 :
12607 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_polaroffsetangle_get",&obj0)) SWIG_fail;
12608 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12609 0 : if (!SWIG_IsOK(res1)) {
12610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_polaroffsetangle_get" "', argument " "1"" of type '" "struct styleObj *""'");
12611 : }
12612 0 : arg1 = (struct styleObj *)(argp1);
12613 0 : result = (double) ((arg1)->polaroffsetangle);
12614 0 : resultobj = SWIG_From_double((double)(result));
12615 0 : return resultobj;
12616 0 : fail:
12617 : return NULL;
12618 : }
12619 :
12620 :
12621 0 : SWIGINTERN PyObject *_wrap_styleObj_angle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12622 : PyObject *resultobj = 0;
12623 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12624 : double arg2 ;
12625 0 : void *argp1 = 0 ;
12626 : int res1 = 0 ;
12627 : double val2 ;
12628 : int ecode2 = 0 ;
12629 0 : PyObject * obj0 = 0 ;
12630 0 : PyObject * obj1 = 0 ;
12631 :
12632 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_angle_set",&obj0,&obj1)) SWIG_fail;
12633 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12634 0 : if (!SWIG_IsOK(res1)) {
12635 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_angle_set" "', argument " "1"" of type '" "struct styleObj *""'");
12636 : }
12637 0 : arg1 = (struct styleObj *)(argp1);
12638 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12639 0 : if (!SWIG_IsOK(ecode2)) {
12640 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_angle_set" "', argument " "2"" of type '" "double""'");
12641 : }
12642 0 : arg2 = (double)(val2);
12643 0 : if (arg1) (arg1)->angle = arg2;
12644 : resultobj = SWIG_Py_Void();
12645 0 : return resultobj;
12646 0 : fail:
12647 : return NULL;
12648 : }
12649 :
12650 :
12651 0 : SWIGINTERN PyObject *_wrap_styleObj_angle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12652 : PyObject *resultobj = 0;
12653 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12654 0 : void *argp1 = 0 ;
12655 : int res1 = 0 ;
12656 0 : PyObject * obj0 = 0 ;
12657 : double result;
12658 :
12659 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_angle_get",&obj0)) SWIG_fail;
12660 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12661 0 : if (!SWIG_IsOK(res1)) {
12662 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_angle_get" "', argument " "1"" of type '" "struct styleObj *""'");
12663 : }
12664 0 : arg1 = (struct styleObj *)(argp1);
12665 0 : result = (double) ((arg1)->angle);
12666 0 : resultobj = SWIG_From_double((double)(result));
12667 0 : return resultobj;
12668 0 : fail:
12669 : return NULL;
12670 : }
12671 :
12672 :
12673 0 : SWIGINTERN PyObject *_wrap_styleObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12674 : PyObject *resultobj = 0;
12675 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12676 : double arg2 ;
12677 0 : void *argp1 = 0 ;
12678 : int res1 = 0 ;
12679 : double val2 ;
12680 : int ecode2 = 0 ;
12681 0 : PyObject * obj0 = 0 ;
12682 0 : PyObject * obj1 = 0 ;
12683 :
12684 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
12685 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12686 0 : if (!SWIG_IsOK(res1)) {
12687 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minscaledenom_set" "', argument " "1"" of type '" "struct styleObj *""'");
12688 : }
12689 0 : arg1 = (struct styleObj *)(argp1);
12690 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12691 0 : if (!SWIG_IsOK(ecode2)) {
12692 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
12693 : }
12694 0 : arg2 = (double)(val2);
12695 0 : if (arg1) (arg1)->minscaledenom = arg2;
12696 : resultobj = SWIG_Py_Void();
12697 0 : return resultobj;
12698 0 : fail:
12699 : return NULL;
12700 : }
12701 :
12702 :
12703 0 : SWIGINTERN PyObject *_wrap_styleObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12704 : PyObject *resultobj = 0;
12705 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12706 0 : void *argp1 = 0 ;
12707 : int res1 = 0 ;
12708 0 : PyObject * obj0 = 0 ;
12709 : double result;
12710 :
12711 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_minscaledenom_get",&obj0)) SWIG_fail;
12712 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12713 0 : if (!SWIG_IsOK(res1)) {
12714 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_minscaledenom_get" "', argument " "1"" of type '" "struct styleObj *""'");
12715 : }
12716 0 : arg1 = (struct styleObj *)(argp1);
12717 0 : result = (double) ((arg1)->minscaledenom);
12718 0 : resultobj = SWIG_From_double((double)(result));
12719 0 : return resultobj;
12720 0 : fail:
12721 : return NULL;
12722 : }
12723 :
12724 :
12725 0 : SWIGINTERN PyObject *_wrap_styleObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12726 : PyObject *resultobj = 0;
12727 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12728 : double arg2 ;
12729 0 : void *argp1 = 0 ;
12730 : int res1 = 0 ;
12731 : double val2 ;
12732 : int ecode2 = 0 ;
12733 0 : PyObject * obj0 = 0 ;
12734 0 : PyObject * obj1 = 0 ;
12735 :
12736 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
12737 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12738 0 : if (!SWIG_IsOK(res1)) {
12739 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxscaledenom_set" "', argument " "1"" of type '" "struct styleObj *""'");
12740 : }
12741 0 : arg1 = (struct styleObj *)(argp1);
12742 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
12743 0 : if (!SWIG_IsOK(ecode2)) {
12744 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
12745 : }
12746 0 : arg2 = (double)(val2);
12747 0 : if (arg1) (arg1)->maxscaledenom = arg2;
12748 : resultobj = SWIG_Py_Void();
12749 0 : return resultobj;
12750 0 : fail:
12751 : return NULL;
12752 : }
12753 :
12754 :
12755 0 : SWIGINTERN PyObject *_wrap_styleObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12756 : PyObject *resultobj = 0;
12757 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12758 0 : void *argp1 = 0 ;
12759 : int res1 = 0 ;
12760 0 : PyObject * obj0 = 0 ;
12761 : double result;
12762 :
12763 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_maxscaledenom_get",&obj0)) SWIG_fail;
12764 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12765 0 : if (!SWIG_IsOK(res1)) {
12766 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_maxscaledenom_get" "', argument " "1"" of type '" "struct styleObj *""'");
12767 : }
12768 0 : arg1 = (struct styleObj *)(argp1);
12769 0 : result = (double) ((arg1)->maxscaledenom);
12770 0 : resultobj = SWIG_From_double((double)(result));
12771 0 : return resultobj;
12772 0 : fail:
12773 : return NULL;
12774 : }
12775 :
12776 :
12777 0 : SWIGINTERN PyObject *_wrap_styleObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12778 : PyObject *resultobj = 0;
12779 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12780 : int arg2 ;
12781 0 : void *argp1 = 0 ;
12782 : int res1 = 0 ;
12783 : int val2 ;
12784 : int ecode2 = 0 ;
12785 0 : PyObject * obj0 = 0 ;
12786 0 : PyObject * obj1 = 0 ;
12787 :
12788 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
12789 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12790 0 : if (!SWIG_IsOK(res1)) {
12791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_sizeunits_set" "', argument " "1"" of type '" "struct styleObj *""'");
12792 : }
12793 0 : arg1 = (struct styleObj *)(argp1);
12794 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12795 0 : if (!SWIG_IsOK(ecode2)) {
12796 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
12797 : }
12798 : arg2 = (int)(val2);
12799 0 : if (arg1) (arg1)->sizeunits = arg2;
12800 : resultobj = SWIG_Py_Void();
12801 0 : return resultobj;
12802 0 : fail:
12803 : return NULL;
12804 : }
12805 :
12806 :
12807 0 : SWIGINTERN PyObject *_wrap_styleObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12808 : PyObject *resultobj = 0;
12809 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12810 0 : void *argp1 = 0 ;
12811 : int res1 = 0 ;
12812 0 : PyObject * obj0 = 0 ;
12813 : int result;
12814 :
12815 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_sizeunits_get",&obj0)) SWIG_fail;
12816 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12817 0 : if (!SWIG_IsOK(res1)) {
12818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_sizeunits_get" "', argument " "1"" of type '" "struct styleObj *""'");
12819 : }
12820 0 : arg1 = (struct styleObj *)(argp1);
12821 0 : result = (int) ((arg1)->sizeunits);
12822 : resultobj = SWIG_From_int((int)(result));
12823 0 : return resultobj;
12824 0 : fail:
12825 : return NULL;
12826 : }
12827 :
12828 :
12829 1 : SWIGINTERN PyObject *_wrap_new_styleObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12830 : PyObject *resultobj = 0;
12831 : classObj *arg1 = (classObj *) NULL ;
12832 1 : void *argp1 = 0 ;
12833 : int res1 = 0 ;
12834 1 : PyObject * obj0 = 0 ;
12835 : struct styleObj *result = 0 ;
12836 :
12837 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_styleObj",&obj0)) SWIG_fail;
12838 1 : if (obj0) {
12839 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
12840 1 : if (!SWIG_IsOK(res1)) {
12841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_styleObj" "', argument " "1"" of type '" "classObj *""'");
12842 : }
12843 1 : arg1 = (classObj *)(argp1);
12844 : }
12845 : {
12846 1 : result = (struct styleObj *)new_styleObj(arg1); {
12847 1 : errorObj *ms_error = msGetErrorObj();
12848 :
12849 1 : switch(ms_error->code) {
12850 : case MS_NOERR:
12851 : break;
12852 0 : case MS_NOTFOUND:
12853 0 : msResetErrorList();
12854 0 : break;
12855 : case -1:
12856 : break;
12857 0 : case MS_IOERR:
12858 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
12859 0 : _raise_ms_exception();
12860 0 : msResetErrorList();
12861 0 : return NULL;
12862 : }
12863 : default:
12864 0 : _raise_ms_exception();
12865 0 : msResetErrorList();
12866 0 : return NULL;
12867 : }
12868 :
12869 : }
12870 : }
12871 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_NEW | 0 );
12872 1 : return resultobj;
12873 0 : fail:
12874 : return NULL;
12875 : }
12876 :
12877 :
12878 1 : SWIGINTERN PyObject *_wrap_delete_styleObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12879 : PyObject *resultobj = 0;
12880 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12881 1 : void *argp1 = 0 ;
12882 : int res1 = 0 ;
12883 1 : PyObject * obj0 = 0 ;
12884 :
12885 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_styleObj",&obj0)) SWIG_fail;
12886 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, SWIG_POINTER_DISOWN | 0 );
12887 1 : if (!SWIG_IsOK(res1)) {
12888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_styleObj" "', argument " "1"" of type '" "struct styleObj *""'");
12889 : }
12890 1 : arg1 = (struct styleObj *)(argp1);
12891 : {
12892 1 : delete_styleObj(arg1); {
12893 1 : errorObj *ms_error = msGetErrorObj();
12894 :
12895 1 : switch(ms_error->code) {
12896 : case MS_NOERR:
12897 : break;
12898 0 : case MS_NOTFOUND:
12899 0 : msResetErrorList();
12900 0 : break;
12901 : case -1:
12902 : break;
12903 0 : case MS_IOERR:
12904 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
12905 0 : _raise_ms_exception();
12906 0 : msResetErrorList();
12907 0 : return NULL;
12908 : }
12909 : default:
12910 0 : _raise_ms_exception();
12911 0 : msResetErrorList();
12912 0 : return NULL;
12913 : }
12914 :
12915 : }
12916 : }
12917 : resultobj = SWIG_Py_Void();
12918 1 : return resultobj;
12919 0 : fail:
12920 : return NULL;
12921 : }
12922 :
12923 :
12924 1 : SWIGINTERN PyObject *_wrap_styleObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12925 : PyObject *resultobj = 0;
12926 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12927 : char *arg2 = (char *) 0 ;
12928 1 : void *argp1 = 0 ;
12929 : int res1 = 0 ;
12930 : int res2 ;
12931 1 : char *buf2 = 0 ;
12932 1 : int alloc2 = 0 ;
12933 1 : PyObject * obj0 = 0 ;
12934 1 : PyObject * obj1 = 0 ;
12935 : int result;
12936 :
12937 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_updateFromString",&obj0,&obj1)) SWIG_fail;
12938 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12939 1 : if (!SWIG_IsOK(res1)) {
12940 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_updateFromString" "', argument " "1"" of type '" "struct styleObj *""'");
12941 : }
12942 1 : arg1 = (struct styleObj *)(argp1);
12943 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
12944 1 : if (!SWIG_IsOK(res2)) {
12945 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_updateFromString" "', argument " "2"" of type '" "char *""'");
12946 : }
12947 1 : arg2 = (char *)(buf2);
12948 : {
12949 : result = (int)styleObj_updateFromString(arg1,arg2); {
12950 1 : errorObj *ms_error = msGetErrorObj();
12951 :
12952 1 : switch(ms_error->code) {
12953 : case MS_NOERR:
12954 : break;
12955 0 : case MS_NOTFOUND:
12956 0 : msResetErrorList();
12957 0 : break;
12958 : case -1:
12959 : break;
12960 0 : case MS_IOERR:
12961 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
12962 0 : _raise_ms_exception();
12963 0 : msResetErrorList();
12964 0 : return NULL;
12965 : }
12966 : default:
12967 0 : _raise_ms_exception();
12968 0 : msResetErrorList();
12969 0 : return NULL;
12970 : }
12971 :
12972 : }
12973 : }
12974 : resultobj = SWIG_From_int((int)(result));
12975 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12976 : return resultobj;
12977 0 : fail:
12978 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
12979 : return NULL;
12980 : }
12981 :
12982 :
12983 1 : SWIGINTERN PyObject *_wrap_styleObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12984 : PyObject *resultobj = 0;
12985 : struct styleObj *arg1 = (struct styleObj *) 0 ;
12986 1 : void *argp1 = 0 ;
12987 : int res1 = 0 ;
12988 1 : PyObject * obj0 = 0 ;
12989 : char *result = 0 ;
12990 :
12991 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_convertToString",&obj0)) SWIG_fail;
12992 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
12993 1 : if (!SWIG_IsOK(res1)) {
12994 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_convertToString" "', argument " "1"" of type '" "struct styleObj *""'");
12995 : }
12996 1 : arg1 = (struct styleObj *)(argp1);
12997 : {
12998 : result = (char *)styleObj_convertToString(arg1); {
12999 1 : errorObj *ms_error = msGetErrorObj();
13000 :
13001 1 : switch(ms_error->code) {
13002 : case MS_NOERR:
13003 : break;
13004 0 : case MS_NOTFOUND:
13005 0 : msResetErrorList();
13006 0 : break;
13007 : case -1:
13008 : break;
13009 0 : case MS_IOERR:
13010 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13011 0 : _raise_ms_exception();
13012 0 : msResetErrorList();
13013 0 : return NULL;
13014 : }
13015 : default:
13016 0 : _raise_ms_exception();
13017 0 : msResetErrorList();
13018 0 : return NULL;
13019 : }
13020 :
13021 : }
13022 : }
13023 1 : resultobj = SWIG_FromCharPtr((const char *)result);
13024 1 : free((char*)result);
13025 1 : return resultobj;
13026 0 : fail:
13027 : return NULL;
13028 : }
13029 :
13030 :
13031 1 : SWIGINTERN PyObject *_wrap_styleObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13032 : PyObject *resultobj = 0;
13033 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13034 1 : void *argp1 = 0 ;
13035 : int res1 = 0 ;
13036 1 : PyObject * obj0 = 0 ;
13037 : styleObj *result = 0 ;
13038 :
13039 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_clone",&obj0)) SWIG_fail;
13040 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13041 1 : if (!SWIG_IsOK(res1)) {
13042 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_clone" "', argument " "1"" of type '" "struct styleObj *""'");
13043 : }
13044 1 : arg1 = (struct styleObj *)(argp1);
13045 : {
13046 1 : result = (styleObj *)styleObj_clone(arg1); {
13047 1 : errorObj *ms_error = msGetErrorObj();
13048 :
13049 1 : switch(ms_error->code) {
13050 : case MS_NOERR:
13051 : break;
13052 0 : case MS_NOTFOUND:
13053 0 : msResetErrorList();
13054 0 : break;
13055 : case -1:
13056 : break;
13057 0 : case MS_IOERR:
13058 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13059 0 : _raise_ms_exception();
13060 0 : msResetErrorList();
13061 0 : return NULL;
13062 : }
13063 : default:
13064 0 : _raise_ms_exception();
13065 0 : msResetErrorList();
13066 0 : return NULL;
13067 : }
13068 :
13069 : }
13070 : }
13071 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN | 0 );
13072 1 : return resultobj;
13073 0 : fail:
13074 : return NULL;
13075 : }
13076 :
13077 :
13078 1 : SWIGINTERN PyObject *_wrap_styleObj_setSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13079 : PyObject *resultobj = 0;
13080 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13081 : mapObj *arg2 = (mapObj *) 0 ;
13082 : char *arg3 = (char *) 0 ;
13083 1 : void *argp1 = 0 ;
13084 : int res1 = 0 ;
13085 1 : void *argp2 = 0 ;
13086 : int res2 = 0 ;
13087 : int res3 ;
13088 1 : char *buf3 = 0 ;
13089 1 : int alloc3 = 0 ;
13090 1 : PyObject * obj0 = 0 ;
13091 1 : PyObject * obj1 = 0 ;
13092 1 : PyObject * obj2 = 0 ;
13093 : int result;
13094 :
13095 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:styleObj_setSymbolByName",&obj0,&obj1,&obj2)) SWIG_fail;
13096 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13097 1 : if (!SWIG_IsOK(res1)) {
13098 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setSymbolByName" "', argument " "1"" of type '" "struct styleObj *""'");
13099 : }
13100 1 : arg1 = (struct styleObj *)(argp1);
13101 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
13102 1 : if (!SWIG_IsOK(res2)) {
13103 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_setSymbolByName" "', argument " "2"" of type '" "mapObj *""'");
13104 : }
13105 1 : arg2 = (mapObj *)(argp2);
13106 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
13107 1 : if (!SWIG_IsOK(res3)) {
13108 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "styleObj_setSymbolByName" "', argument " "3"" of type '" "char *""'");
13109 : }
13110 1 : arg3 = (char *)(buf3);
13111 : {
13112 1 : result = (int)styleObj_setSymbolByName(arg1,arg2,arg3); {
13113 1 : errorObj *ms_error = msGetErrorObj();
13114 :
13115 1 : switch(ms_error->code) {
13116 : case MS_NOERR:
13117 : break;
13118 0 : case MS_NOTFOUND:
13119 0 : msResetErrorList();
13120 0 : break;
13121 : case -1:
13122 : break;
13123 0 : case MS_IOERR:
13124 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13125 0 : _raise_ms_exception();
13126 0 : msResetErrorList();
13127 0 : return NULL;
13128 : }
13129 : default:
13130 0 : _raise_ms_exception();
13131 0 : msResetErrorList();
13132 0 : return NULL;
13133 : }
13134 :
13135 : }
13136 : }
13137 : resultobj = SWIG_From_int((int)(result));
13138 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13139 : return resultobj;
13140 0 : fail:
13141 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13142 : return NULL;
13143 : }
13144 :
13145 :
13146 0 : SWIGINTERN PyObject *_wrap_styleObj_removeBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13147 : PyObject *resultobj = 0;
13148 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13149 : int arg2 ;
13150 0 : void *argp1 = 0 ;
13151 : int res1 = 0 ;
13152 : int val2 ;
13153 : int ecode2 = 0 ;
13154 0 : PyObject * obj0 = 0 ;
13155 0 : PyObject * obj1 = 0 ;
13156 : int result;
13157 :
13158 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_removeBinding",&obj0,&obj1)) SWIG_fail;
13159 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13160 0 : if (!SWIG_IsOK(res1)) {
13161 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_removeBinding" "', argument " "1"" of type '" "struct styleObj *""'");
13162 : }
13163 0 : arg1 = (struct styleObj *)(argp1);
13164 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
13165 0 : if (!SWIG_IsOK(ecode2)) {
13166 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_removeBinding" "', argument " "2"" of type '" "int""'");
13167 : }
13168 : arg2 = (int)(val2);
13169 : {
13170 : result = (int)styleObj_removeBinding(arg1,arg2); {
13171 0 : errorObj *ms_error = msGetErrorObj();
13172 :
13173 0 : switch(ms_error->code) {
13174 : case MS_NOERR:
13175 : break;
13176 0 : case MS_NOTFOUND:
13177 0 : msResetErrorList();
13178 0 : break;
13179 : case -1:
13180 : break;
13181 0 : case MS_IOERR:
13182 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13183 0 : _raise_ms_exception();
13184 0 : msResetErrorList();
13185 0 : return NULL;
13186 : }
13187 : default:
13188 0 : _raise_ms_exception();
13189 0 : msResetErrorList();
13190 0 : return NULL;
13191 : }
13192 :
13193 : }
13194 : }
13195 : resultobj = SWIG_From_int((int)(result));
13196 0 : return resultobj;
13197 0 : fail:
13198 : return NULL;
13199 : }
13200 :
13201 :
13202 1 : SWIGINTERN PyObject *_wrap_styleObj_setBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13203 : PyObject *resultobj = 0;
13204 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13205 : int arg2 ;
13206 : char *arg3 = (char *) 0 ;
13207 1 : void *argp1 = 0 ;
13208 : int res1 = 0 ;
13209 : int val2 ;
13210 : int ecode2 = 0 ;
13211 : int res3 ;
13212 1 : char *buf3 = 0 ;
13213 1 : int alloc3 = 0 ;
13214 1 : PyObject * obj0 = 0 ;
13215 1 : PyObject * obj1 = 0 ;
13216 1 : PyObject * obj2 = 0 ;
13217 : int result;
13218 :
13219 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:styleObj_setBinding",&obj0,&obj1,&obj2)) SWIG_fail;
13220 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13221 1 : if (!SWIG_IsOK(res1)) {
13222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setBinding" "', argument " "1"" of type '" "struct styleObj *""'");
13223 : }
13224 1 : arg1 = (struct styleObj *)(argp1);
13225 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
13226 1 : if (!SWIG_IsOK(ecode2)) {
13227 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_setBinding" "', argument " "2"" of type '" "int""'");
13228 : }
13229 : arg2 = (int)(val2);
13230 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
13231 1 : if (!SWIG_IsOK(res3)) {
13232 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "styleObj_setBinding" "', argument " "3"" of type '" "char *""'");
13233 : }
13234 1 : arg3 = (char *)(buf3);
13235 : {
13236 1 : result = (int)styleObj_setBinding(arg1,arg2,arg3); {
13237 1 : errorObj *ms_error = msGetErrorObj();
13238 :
13239 1 : switch(ms_error->code) {
13240 : case MS_NOERR:
13241 : break;
13242 0 : case MS_NOTFOUND:
13243 0 : msResetErrorList();
13244 0 : break;
13245 : case -1:
13246 : break;
13247 0 : case MS_IOERR:
13248 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13249 0 : _raise_ms_exception();
13250 0 : msResetErrorList();
13251 0 : return NULL;
13252 : }
13253 : default:
13254 0 : _raise_ms_exception();
13255 0 : msResetErrorList();
13256 0 : return NULL;
13257 : }
13258 :
13259 : }
13260 : }
13261 : resultobj = SWIG_From_int((int)(result));
13262 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13263 : return resultobj;
13264 0 : fail:
13265 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
13266 : return NULL;
13267 : }
13268 :
13269 :
13270 1 : SWIGINTERN PyObject *_wrap_styleObj_getBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13271 : PyObject *resultobj = 0;
13272 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13273 : int arg2 ;
13274 1 : void *argp1 = 0 ;
13275 : int res1 = 0 ;
13276 : int val2 ;
13277 : int ecode2 = 0 ;
13278 1 : PyObject * obj0 = 0 ;
13279 1 : PyObject * obj1 = 0 ;
13280 : char *result = 0 ;
13281 :
13282 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_getBinding",&obj0,&obj1)) SWIG_fail;
13283 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13284 1 : if (!SWIG_IsOK(res1)) {
13285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_getBinding" "', argument " "1"" of type '" "struct styleObj *""'");
13286 : }
13287 1 : arg1 = (struct styleObj *)(argp1);
13288 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
13289 1 : if (!SWIG_IsOK(ecode2)) {
13290 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "styleObj_getBinding" "', argument " "2"" of type '" "int""'");
13291 : }
13292 : arg2 = (int)(val2);
13293 : {
13294 : result = (char *)styleObj_getBinding(arg1,arg2); {
13295 1 : errorObj *ms_error = msGetErrorObj();
13296 :
13297 1 : switch(ms_error->code) {
13298 : case MS_NOERR:
13299 : break;
13300 0 : case MS_NOTFOUND:
13301 0 : msResetErrorList();
13302 0 : break;
13303 : case -1:
13304 : break;
13305 0 : case MS_IOERR:
13306 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13307 0 : _raise_ms_exception();
13308 0 : msResetErrorList();
13309 0 : return NULL;
13310 : }
13311 : default:
13312 0 : _raise_ms_exception();
13313 0 : msResetErrorList();
13314 0 : return NULL;
13315 : }
13316 :
13317 : }
13318 : }
13319 1 : resultobj = SWIG_FromCharPtr((const char *)result);
13320 1 : return resultobj;
13321 0 : fail:
13322 : return NULL;
13323 : }
13324 :
13325 :
13326 0 : SWIGINTERN PyObject *_wrap_styleObj_getGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13327 : PyObject *resultobj = 0;
13328 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13329 0 : void *argp1 = 0 ;
13330 : int res1 = 0 ;
13331 0 : PyObject * obj0 = 0 ;
13332 : char *result = 0 ;
13333 :
13334 0 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_getGeomTransform",&obj0)) SWIG_fail;
13335 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13336 0 : if (!SWIG_IsOK(res1)) {
13337 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_getGeomTransform" "', argument " "1"" of type '" "struct styleObj *""'");
13338 : }
13339 0 : arg1 = (struct styleObj *)(argp1);
13340 : {
13341 0 : result = (char *)styleObj_getGeomTransform(arg1); {
13342 0 : errorObj *ms_error = msGetErrorObj();
13343 :
13344 0 : switch(ms_error->code) {
13345 : case MS_NOERR:
13346 : break;
13347 0 : case MS_NOTFOUND:
13348 0 : msResetErrorList();
13349 0 : break;
13350 : case -1:
13351 : break;
13352 0 : case MS_IOERR:
13353 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13354 0 : _raise_ms_exception();
13355 0 : msResetErrorList();
13356 0 : return NULL;
13357 : }
13358 : default:
13359 0 : _raise_ms_exception();
13360 0 : msResetErrorList();
13361 0 : return NULL;
13362 : }
13363 :
13364 : }
13365 : }
13366 0 : resultobj = SWIG_FromCharPtr((const char *)result);
13367 0 : return resultobj;
13368 0 : fail:
13369 : return NULL;
13370 : }
13371 :
13372 :
13373 0 : SWIGINTERN PyObject *_wrap_styleObj_setGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13374 : PyObject *resultobj = 0;
13375 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13376 : char *arg2 = (char *) 0 ;
13377 0 : void *argp1 = 0 ;
13378 : int res1 = 0 ;
13379 : int res2 ;
13380 0 : char *buf2 = 0 ;
13381 0 : int alloc2 = 0 ;
13382 0 : PyObject * obj0 = 0 ;
13383 0 : PyObject * obj1 = 0 ;
13384 :
13385 0 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_setGeomTransform",&obj0,&obj1)) SWIG_fail;
13386 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13387 0 : if (!SWIG_IsOK(res1)) {
13388 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_setGeomTransform" "', argument " "1"" of type '" "struct styleObj *""'");
13389 : }
13390 0 : arg1 = (struct styleObj *)(argp1);
13391 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13392 0 : if (!SWIG_IsOK(res2)) {
13393 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "styleObj_setGeomTransform" "', argument " "2"" of type '" "char *""'");
13394 : }
13395 0 : arg2 = (char *)(buf2);
13396 : {
13397 : styleObj_setGeomTransform(arg1,arg2); {
13398 0 : errorObj *ms_error = msGetErrorObj();
13399 :
13400 0 : switch(ms_error->code) {
13401 : case MS_NOERR:
13402 : break;
13403 0 : case MS_NOTFOUND:
13404 0 : msResetErrorList();
13405 0 : break;
13406 : case -1:
13407 : break;
13408 0 : case MS_IOERR:
13409 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13410 0 : _raise_ms_exception();
13411 0 : msResetErrorList();
13412 0 : return NULL;
13413 : }
13414 : default:
13415 0 : _raise_ms_exception();
13416 0 : msResetErrorList();
13417 0 : return NULL;
13418 : }
13419 :
13420 : }
13421 : }
13422 : resultobj = SWIG_Py_Void();
13423 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13424 : return resultobj;
13425 0 : fail:
13426 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13427 : return NULL;
13428 : }
13429 :
13430 :
13431 1 : SWIGINTERN PyObject *_wrap_styleObj_pattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 : PyObject *resultobj = 0;
13433 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13434 : int arg2 ;
13435 : double *arg3 = (double *) 0 ;
13436 1 : void *argp1 = 0 ;
13437 : int res1 = 0 ;
13438 1 : PyObject * obj0 = 0 ;
13439 1 : PyObject * obj1 = 0 ;
13440 :
13441 1 : if (!PyArg_ParseTuple(args,(char *)"OO:styleObj_pattern_set",&obj0,&obj1)) SWIG_fail;
13442 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13443 1 : if (!SWIG_IsOK(res1)) {
13444 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_pattern_set" "', argument " "1"" of type '" "struct styleObj *""'");
13445 : }
13446 1 : arg1 = (struct styleObj *)(argp1);
13447 : {
13448 : int i;
13449 : /* %typemap(in,numinputs=1) (int nListSize, double* pListValues)*/
13450 : /* check if is List */
13451 1 : if ( !PySequence_Check(obj1) ) {
13452 0 : PyErr_SetString(PyExc_TypeError, "not a sequence");
13453 : SWIG_fail;
13454 : }
13455 1 : arg2 = (int) PySequence_Size(obj1);
13456 1 : arg3 = (double*) malloc(arg2*sizeof(double));
13457 1 : for( i = 0; i<arg2; i++ ) {
13458 1 : PyObject *o = PySequence_GetItem(obj1,i);
13459 1 : if ( !PyArg_Parse(o,"d",&arg3[i]) ) {
13460 0 : PyErr_SetString(PyExc_TypeError, "not a number");
13461 0 : Py_DECREF(o);
13462 : SWIG_fail;
13463 : }
13464 1 : Py_DECREF(o);
13465 : }
13466 : }
13467 : {
13468 1 : styleObj_pattern_set(arg1,arg2,arg3); {
13469 1 : errorObj *ms_error = msGetErrorObj();
13470 :
13471 1 : switch(ms_error->code) {
13472 : case MS_NOERR:
13473 : break;
13474 0 : case MS_NOTFOUND:
13475 0 : msResetErrorList();
13476 0 : break;
13477 : case -1:
13478 : break;
13479 0 : case MS_IOERR:
13480 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13481 0 : _raise_ms_exception();
13482 0 : msResetErrorList();
13483 0 : return NULL;
13484 : }
13485 : default:
13486 1 : _raise_ms_exception();
13487 1 : msResetErrorList();
13488 1 : return NULL;
13489 : }
13490 :
13491 : }
13492 : }
13493 : resultobj = SWIG_Py_Void();
13494 : {
13495 : /* %typemap(freearg) (int nListSize, double* pListValues) */
13496 1 : if (arg3) {
13497 1 : free((void*) arg3);
13498 : }
13499 : }
13500 : return resultobj;
13501 0 : fail:
13502 : {
13503 : /* %typemap(freearg) (int nListSize, double* pListValues) */
13504 0 : if (arg3) {
13505 0 : free((void*) arg3);
13506 : }
13507 : }
13508 : return NULL;
13509 : }
13510 :
13511 :
13512 1 : SWIGINTERN PyObject *_wrap_styleObj_pattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13513 : PyObject *resultobj = 0;
13514 : struct styleObj *arg1 = (struct styleObj *) 0 ;
13515 : double **arg2 = (double **) 0 ;
13516 : int *arg3 = (int *) 0 ;
13517 1 : void *argp1 = 0 ;
13518 : int res1 = 0 ;
13519 : double *argout2 ;
13520 : int nListSize2 ;
13521 1 : PyObject * obj0 = 0 ;
13522 :
13523 : {
13524 : /* %typemap(python,in,numinputs=0) (double *val, int*hasval) */
13525 : arg2 = &argout2;
13526 : arg3 = &nListSize2;
13527 : }
13528 1 : if (!PyArg_ParseTuple(args,(char *)"O:styleObj_pattern_get",&obj0)) SWIG_fail;
13529 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_styleObj, 0 | 0 );
13530 1 : if (!SWIG_IsOK(res1)) {
13531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "styleObj_pattern_get" "', argument " "1"" of type '" "struct styleObj *""'");
13532 : }
13533 1 : arg1 = (struct styleObj *)(argp1);
13534 : {
13535 1 : styleObj_pattern_get(arg1,arg2,arg3); {
13536 1 : errorObj *ms_error = msGetErrorObj();
13537 :
13538 1 : switch(ms_error->code) {
13539 : case MS_NOERR:
13540 : break;
13541 0 : case MS_NOTFOUND:
13542 0 : msResetErrorList();
13543 0 : break;
13544 : case -1:
13545 : break;
13546 0 : case MS_IOERR:
13547 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13548 0 : _raise_ms_exception();
13549 0 : msResetErrorList();
13550 0 : return NULL;
13551 : }
13552 : default:
13553 0 : _raise_ms_exception();
13554 0 : msResetErrorList();
13555 0 : return NULL;
13556 : }
13557 :
13558 : }
13559 : }
13560 : resultobj = SWIG_Py_Void();
13561 : {
13562 : /* %typemap(argout) (double* argout, int* pnListSize) */
13563 : PyObject *r;
13564 1 : r = CreateTupleFromDoubleArray(*arg2, *arg3);
13565 1 : free(*arg2);
13566 1 : resultobj = t_output_helper(resultobj,r);
13567 : }
13568 1 : return resultobj;
13569 0 : fail:
13570 : return NULL;
13571 : }
13572 :
13573 :
13574 1 : SWIGINTERN PyObject *styleObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13575 : PyObject *obj;
13576 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
13577 1 : SWIG_TypeNewClientData(SWIGTYPE_p_styleObj, SWIG_NewClientData(obj));
13578 1 : return SWIG_Py_Void();
13579 : }
13580 :
13581 0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_maxdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13582 : PyObject *resultobj = 0;
13583 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13584 : int arg2 ;
13585 0 : void *argp1 = 0 ;
13586 : int res1 = 0 ;
13587 : int val2 ;
13588 : int ecode2 = 0 ;
13589 0 : PyObject * obj0 = 0 ;
13590 0 : PyObject * obj1 = 0 ;
13591 :
13592 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelLeaderObj_maxdistance_set",&obj0,&obj1)) SWIG_fail;
13593 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 | 0 );
13594 0 : if (!SWIG_IsOK(res1)) {
13595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_maxdistance_set" "', argument " "1"" of type '" "labelLeaderObj *""'");
13596 : }
13597 0 : arg1 = (labelLeaderObj *)(argp1);
13598 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 0 : if (!SWIG_IsOK(ecode2)) {
13600 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelLeaderObj_maxdistance_set" "', argument " "2"" of type '" "int""'");
13601 : }
13602 : arg2 = (int)(val2);
13603 0 : if (arg1) (arg1)->maxdistance = arg2;
13604 : resultobj = SWIG_Py_Void();
13605 0 : return resultobj;
13606 0 : fail:
13607 : return NULL;
13608 : }
13609 :
13610 :
13611 0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_maxdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13612 : PyObject *resultobj = 0;
13613 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13614 0 : void *argp1 = 0 ;
13615 : int res1 = 0 ;
13616 0 : PyObject * obj0 = 0 ;
13617 : int result;
13618 :
13619 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_maxdistance_get",&obj0)) SWIG_fail;
13620 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 | 0 );
13621 0 : if (!SWIG_IsOK(res1)) {
13622 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_maxdistance_get" "', argument " "1"" of type '" "labelLeaderObj *""'");
13623 : }
13624 0 : arg1 = (labelLeaderObj *)(argp1);
13625 0 : result = (int) ((arg1)->maxdistance);
13626 : resultobj = SWIG_From_int((int)(result));
13627 0 : return resultobj;
13628 0 : fail:
13629 : return NULL;
13630 : }
13631 :
13632 :
13633 0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_gridstep_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13634 : PyObject *resultobj = 0;
13635 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13636 : int arg2 ;
13637 0 : void *argp1 = 0 ;
13638 : int res1 = 0 ;
13639 : int val2 ;
13640 : int ecode2 = 0 ;
13641 0 : PyObject * obj0 = 0 ;
13642 0 : PyObject * obj1 = 0 ;
13643 :
13644 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelLeaderObj_gridstep_set",&obj0,&obj1)) SWIG_fail;
13645 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 | 0 );
13646 0 : if (!SWIG_IsOK(res1)) {
13647 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_gridstep_set" "', argument " "1"" of type '" "labelLeaderObj *""'");
13648 : }
13649 0 : arg1 = (labelLeaderObj *)(argp1);
13650 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
13651 0 : if (!SWIG_IsOK(ecode2)) {
13652 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelLeaderObj_gridstep_set" "', argument " "2"" of type '" "int""'");
13653 : }
13654 : arg2 = (int)(val2);
13655 0 : if (arg1) (arg1)->gridstep = arg2;
13656 : resultobj = SWIG_Py_Void();
13657 0 : return resultobj;
13658 0 : fail:
13659 : return NULL;
13660 : }
13661 :
13662 :
13663 0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_gridstep_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13664 : PyObject *resultobj = 0;
13665 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13666 0 : void *argp1 = 0 ;
13667 : int res1 = 0 ;
13668 0 : PyObject * obj0 = 0 ;
13669 : int result;
13670 :
13671 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_gridstep_get",&obj0)) SWIG_fail;
13672 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 | 0 );
13673 0 : if (!SWIG_IsOK(res1)) {
13674 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_gridstep_get" "', argument " "1"" of type '" "labelLeaderObj *""'");
13675 : }
13676 0 : arg1 = (labelLeaderObj *)(argp1);
13677 0 : result = (int) ((arg1)->gridstep);
13678 : resultobj = SWIG_From_int((int)(result));
13679 0 : return resultobj;
13680 0 : fail:
13681 : return NULL;
13682 : }
13683 :
13684 :
13685 0 : SWIGINTERN PyObject *_wrap_labelLeaderObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13686 : PyObject *resultobj = 0;
13687 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13688 0 : void *argp1 = 0 ;
13689 : int res1 = 0 ;
13690 0 : PyObject * obj0 = 0 ;
13691 : int result;
13692 :
13693 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelLeaderObj_numstyles_get",&obj0)) SWIG_fail;
13694 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, 0 | 0 );
13695 0 : if (!SWIG_IsOK(res1)) {
13696 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelLeaderObj_numstyles_get" "', argument " "1"" of type '" "labelLeaderObj *""'");
13697 : }
13698 0 : arg1 = (labelLeaderObj *)(argp1);
13699 0 : result = (int) ((arg1)->numstyles);
13700 : resultobj = SWIG_From_int((int)(result));
13701 0 : return resultobj;
13702 0 : fail:
13703 : return NULL;
13704 : }
13705 :
13706 :
13707 0 : SWIGINTERN PyObject *_wrap_new_labelLeaderObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13708 : PyObject *resultobj = 0;
13709 : labelLeaderObj *result = 0 ;
13710 :
13711 0 : if (!PyArg_ParseTuple(args,(char *)":new_labelLeaderObj")) SWIG_fail;
13712 : {
13713 0 : result = (labelLeaderObj *)calloc(1, sizeof(labelLeaderObj)); {
13714 0 : errorObj *ms_error = msGetErrorObj();
13715 :
13716 0 : switch(ms_error->code) {
13717 : case MS_NOERR:
13718 : break;
13719 0 : case MS_NOTFOUND:
13720 0 : msResetErrorList();
13721 0 : break;
13722 : case -1:
13723 : break;
13724 0 : case MS_IOERR:
13725 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13726 0 : _raise_ms_exception();
13727 0 : msResetErrorList();
13728 0 : return NULL;
13729 : }
13730 : default:
13731 0 : _raise_ms_exception();
13732 0 : msResetErrorList();
13733 0 : return NULL;
13734 : }
13735 :
13736 : }
13737 : }
13738 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_NEW | 0 );
13739 0 : return resultobj;
13740 0 : fail:
13741 : return NULL;
13742 : }
13743 :
13744 :
13745 0 : SWIGINTERN PyObject *_wrap_delete_labelLeaderObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13746 : PyObject *resultobj = 0;
13747 : labelLeaderObj *arg1 = (labelLeaderObj *) 0 ;
13748 0 : void *argp1 = 0 ;
13749 : int res1 = 0 ;
13750 0 : PyObject * obj0 = 0 ;
13751 :
13752 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_labelLeaderObj",&obj0)) SWIG_fail;
13753 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_DISOWN | 0 );
13754 0 : if (!SWIG_IsOK(res1)) {
13755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelLeaderObj" "', argument " "1"" of type '" "labelLeaderObj *""'");
13756 : }
13757 0 : arg1 = (labelLeaderObj *)(argp1);
13758 : {
13759 0 : free((char *) arg1); {
13760 0 : errorObj *ms_error = msGetErrorObj();
13761 :
13762 0 : switch(ms_error->code) {
13763 : case MS_NOERR:
13764 : break;
13765 0 : case MS_NOTFOUND:
13766 0 : msResetErrorList();
13767 0 : break;
13768 : case -1:
13769 : break;
13770 0 : case MS_IOERR:
13771 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
13772 0 : _raise_ms_exception();
13773 0 : msResetErrorList();
13774 0 : return NULL;
13775 : }
13776 : default:
13777 0 : _raise_ms_exception();
13778 0 : msResetErrorList();
13779 0 : return NULL;
13780 : }
13781 :
13782 : }
13783 : }
13784 : resultobj = SWIG_Py_Void();
13785 0 : return resultobj;
13786 0 : fail:
13787 : return NULL;
13788 : }
13789 :
13790 :
13791 1 : SWIGINTERN PyObject *labelLeaderObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13792 : PyObject *obj;
13793 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
13794 1 : SWIG_TypeNewClientData(SWIGTYPE_p_labelLeaderObj, SWIG_NewClientData(obj));
13795 1 : return SWIG_Py_Void();
13796 : }
13797 :
13798 0 : SWIGINTERN PyObject *_wrap_labelObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13799 : PyObject *resultobj = 0;
13800 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13801 0 : void *argp1 = 0 ;
13802 : int res1 = 0 ;
13803 0 : PyObject * obj0 = 0 ;
13804 : int result;
13805 :
13806 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_refcount_get",&obj0)) SWIG_fail;
13807 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13808 0 : if (!SWIG_IsOK(res1)) {
13809 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_refcount_get" "', argument " "1"" of type '" "struct labelObj *""'");
13810 : }
13811 0 : arg1 = (struct labelObj *)(argp1);
13812 0 : result = (int) ((arg1)->refcount);
13813 : resultobj = SWIG_From_int((int)(result));
13814 0 : return resultobj;
13815 0 : fail:
13816 : return NULL;
13817 : }
13818 :
13819 :
13820 1 : SWIGINTERN PyObject *_wrap_labelObj_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13821 : PyObject *resultobj = 0;
13822 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13823 : char *arg2 = (char *) 0 ;
13824 1 : void *argp1 = 0 ;
13825 : int res1 = 0 ;
13826 : int res2 ;
13827 1 : char *buf2 = 0 ;
13828 1 : int alloc2 = 0 ;
13829 1 : PyObject * obj0 = 0 ;
13830 1 : PyObject * obj1 = 0 ;
13831 :
13832 1 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_font_set",&obj0,&obj1)) SWIG_fail;
13833 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13834 1 : if (!SWIG_IsOK(res1)) {
13835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_font_set" "', argument " "1"" of type '" "struct labelObj *""'");
13836 : }
13837 1 : arg1 = (struct labelObj *)(argp1);
13838 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
13839 1 : if (!SWIG_IsOK(res2)) {
13840 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_font_set" "', argument " "2"" of type '" "char *""'");
13841 : }
13842 1 : arg2 = (char *)(buf2);
13843 : {
13844 1 : if (arg1->font) free((char*)arg1->font);
13845 1 : if (arg2) {
13846 1 : arg1->font = (char *) malloc(strlen(arg2)+1);
13847 : strcpy((char*)arg1->font,arg2);
13848 : } else {
13849 0 : arg1->font = 0;
13850 : }
13851 : }
13852 : resultobj = SWIG_Py_Void();
13853 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13854 : return resultobj;
13855 0 : fail:
13856 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
13857 : return NULL;
13858 : }
13859 :
13860 :
13861 0 : SWIGINTERN PyObject *_wrap_labelObj_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13862 : PyObject *resultobj = 0;
13863 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13864 0 : void *argp1 = 0 ;
13865 : int res1 = 0 ;
13866 0 : PyObject * obj0 = 0 ;
13867 : char *result = 0 ;
13868 :
13869 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_font_get",&obj0)) SWIG_fail;
13870 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13871 0 : if (!SWIG_IsOK(res1)) {
13872 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_font_get" "', argument " "1"" of type '" "struct labelObj *""'");
13873 : }
13874 0 : arg1 = (struct labelObj *)(argp1);
13875 0 : result = (char *) ((arg1)->font);
13876 0 : resultobj = SWIG_FromCharPtr((const char *)result);
13877 0 : return resultobj;
13878 0 : fail:
13879 : return NULL;
13880 : }
13881 :
13882 :
13883 0 : SWIGINTERN PyObject *_wrap_labelObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13884 : PyObject *resultobj = 0;
13885 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13886 : colorObj *arg2 = (colorObj *) 0 ;
13887 0 : void *argp1 = 0 ;
13888 : int res1 = 0 ;
13889 0 : void *argp2 = 0 ;
13890 : int res2 = 0 ;
13891 0 : PyObject * obj0 = 0 ;
13892 0 : PyObject * obj1 = 0 ;
13893 :
13894 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_color_set",&obj0,&obj1)) SWIG_fail;
13895 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13896 0 : if (!SWIG_IsOK(res1)) {
13897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_color_set" "', argument " "1"" of type '" "struct labelObj *""'");
13898 : }
13899 0 : arg1 = (struct labelObj *)(argp1);
13900 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
13901 0 : if (!SWIG_IsOK(res2)) {
13902 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_color_set" "', argument " "2"" of type '" "colorObj *""'");
13903 : }
13904 0 : arg2 = (colorObj *)(argp2);
13905 0 : if (arg1) (arg1)->color = *arg2;
13906 : resultobj = SWIG_Py_Void();
13907 0 : return resultobj;
13908 0 : fail:
13909 : return NULL;
13910 : }
13911 :
13912 :
13913 1 : SWIGINTERN PyObject *_wrap_labelObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13914 : PyObject *resultobj = 0;
13915 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13916 1 : void *argp1 = 0 ;
13917 : int res1 = 0 ;
13918 1 : PyObject * obj0 = 0 ;
13919 : colorObj *result = 0 ;
13920 :
13921 1 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_color_get",&obj0)) SWIG_fail;
13922 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13923 1 : if (!SWIG_IsOK(res1)) {
13924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_color_get" "', argument " "1"" of type '" "struct labelObj *""'");
13925 : }
13926 1 : arg1 = (struct labelObj *)(argp1);
13927 1 : result = (colorObj *)& ((arg1)->color);
13928 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
13929 1 : return resultobj;
13930 0 : fail:
13931 : return NULL;
13932 : }
13933 :
13934 :
13935 0 : SWIGINTERN PyObject *_wrap_labelObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13936 : PyObject *resultobj = 0;
13937 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13938 : colorObj *arg2 = (colorObj *) 0 ;
13939 0 : void *argp1 = 0 ;
13940 : int res1 = 0 ;
13941 0 : void *argp2 = 0 ;
13942 : int res2 = 0 ;
13943 0 : PyObject * obj0 = 0 ;
13944 0 : PyObject * obj1 = 0 ;
13945 :
13946 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
13947 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13948 0 : if (!SWIG_IsOK(res1)) {
13949 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinecolor_set" "', argument " "1"" of type '" "struct labelObj *""'");
13950 : }
13951 0 : arg1 = (struct labelObj *)(argp1);
13952 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
13953 0 : if (!SWIG_IsOK(res2)) {
13954 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'");
13955 : }
13956 0 : arg2 = (colorObj *)(argp2);
13957 0 : if (arg1) (arg1)->outlinecolor = *arg2;
13958 : resultobj = SWIG_Py_Void();
13959 0 : return resultobj;
13960 0 : fail:
13961 : return NULL;
13962 : }
13963 :
13964 :
13965 1 : SWIGINTERN PyObject *_wrap_labelObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13966 : PyObject *resultobj = 0;
13967 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13968 1 : void *argp1 = 0 ;
13969 : int res1 = 0 ;
13970 1 : PyObject * obj0 = 0 ;
13971 : colorObj *result = 0 ;
13972 :
13973 1 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_outlinecolor_get",&obj0)) SWIG_fail;
13974 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
13975 1 : if (!SWIG_IsOK(res1)) {
13976 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinecolor_get" "', argument " "1"" of type '" "struct labelObj *""'");
13977 : }
13978 1 : arg1 = (struct labelObj *)(argp1);
13979 1 : result = (colorObj *)& ((arg1)->outlinecolor);
13980 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
13981 1 : return resultobj;
13982 0 : fail:
13983 : return NULL;
13984 : }
13985 :
13986 :
13987 0 : SWIGINTERN PyObject *_wrap_labelObj_outlinewidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13988 : PyObject *resultobj = 0;
13989 : struct labelObj *arg1 = (struct labelObj *) 0 ;
13990 : int arg2 ;
13991 0 : void *argp1 = 0 ;
13992 : int res1 = 0 ;
13993 : int val2 ;
13994 : int ecode2 = 0 ;
13995 0 : PyObject * obj0 = 0 ;
13996 0 : PyObject * obj1 = 0 ;
13997 :
13998 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_outlinewidth_set",&obj0,&obj1)) SWIG_fail;
13999 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14000 0 : if (!SWIG_IsOK(res1)) {
14001 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinewidth_set" "', argument " "1"" of type '" "struct labelObj *""'");
14002 : }
14003 0 : arg1 = (struct labelObj *)(argp1);
14004 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14005 0 : if (!SWIG_IsOK(ecode2)) {
14006 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_outlinewidth_set" "', argument " "2"" of type '" "int""'");
14007 : }
14008 : arg2 = (int)(val2);
14009 0 : if (arg1) (arg1)->outlinewidth = arg2;
14010 : resultobj = SWIG_Py_Void();
14011 0 : return resultobj;
14012 0 : fail:
14013 : return NULL;
14014 : }
14015 :
14016 :
14017 0 : SWIGINTERN PyObject *_wrap_labelObj_outlinewidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14018 : PyObject *resultobj = 0;
14019 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14020 0 : void *argp1 = 0 ;
14021 : int res1 = 0 ;
14022 0 : PyObject * obj0 = 0 ;
14023 : int result;
14024 :
14025 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_outlinewidth_get",&obj0)) SWIG_fail;
14026 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14027 0 : if (!SWIG_IsOK(res1)) {
14028 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_outlinewidth_get" "', argument " "1"" of type '" "struct labelObj *""'");
14029 : }
14030 0 : arg1 = (struct labelObj *)(argp1);
14031 0 : result = (int) ((arg1)->outlinewidth);
14032 : resultobj = SWIG_From_int((int)(result));
14033 0 : return resultobj;
14034 0 : fail:
14035 : return NULL;
14036 : }
14037 :
14038 :
14039 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14040 : PyObject *resultobj = 0;
14041 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14042 : colorObj *arg2 = (colorObj *) 0 ;
14043 0 : void *argp1 = 0 ;
14044 : int res1 = 0 ;
14045 0 : void *argp2 = 0 ;
14046 : int res2 = 0 ;
14047 0 : PyObject * obj0 = 0 ;
14048 0 : PyObject * obj1 = 0 ;
14049 :
14050 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowcolor_set",&obj0,&obj1)) SWIG_fail;
14051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14052 0 : if (!SWIG_IsOK(res1)) {
14053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowcolor_set" "', argument " "1"" of type '" "struct labelObj *""'");
14054 : }
14055 0 : arg1 = (struct labelObj *)(argp1);
14056 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
14057 0 : if (!SWIG_IsOK(res2)) {
14058 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_shadowcolor_set" "', argument " "2"" of type '" "colorObj *""'");
14059 : }
14060 0 : arg2 = (colorObj *)(argp2);
14061 0 : if (arg1) (arg1)->shadowcolor = *arg2;
14062 : resultobj = SWIG_Py_Void();
14063 0 : return resultobj;
14064 0 : fail:
14065 : return NULL;
14066 : }
14067 :
14068 :
14069 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14070 : PyObject *resultobj = 0;
14071 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14072 0 : void *argp1 = 0 ;
14073 : int res1 = 0 ;
14074 0 : PyObject * obj0 = 0 ;
14075 : colorObj *result = 0 ;
14076 :
14077 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowcolor_get",&obj0)) SWIG_fail;
14078 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14079 0 : if (!SWIG_IsOK(res1)) {
14080 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowcolor_get" "', argument " "1"" of type '" "struct labelObj *""'");
14081 : }
14082 0 : arg1 = (struct labelObj *)(argp1);
14083 0 : result = (colorObj *)& ((arg1)->shadowcolor);
14084 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
14085 0 : return resultobj;
14086 0 : fail:
14087 : return NULL;
14088 : }
14089 :
14090 :
14091 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14092 : PyObject *resultobj = 0;
14093 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14094 : int arg2 ;
14095 0 : void *argp1 = 0 ;
14096 : int res1 = 0 ;
14097 : int val2 ;
14098 : int ecode2 = 0 ;
14099 0 : PyObject * obj0 = 0 ;
14100 0 : PyObject * obj1 = 0 ;
14101 :
14102 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowsizex_set",&obj0,&obj1)) SWIG_fail;
14103 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14104 0 : if (!SWIG_IsOK(res1)) {
14105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizex_set" "', argument " "1"" of type '" "struct labelObj *""'");
14106 : }
14107 0 : arg1 = (struct labelObj *)(argp1);
14108 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14109 0 : if (!SWIG_IsOK(ecode2)) {
14110 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_shadowsizex_set" "', argument " "2"" of type '" "int""'");
14111 : }
14112 : arg2 = (int)(val2);
14113 0 : if (arg1) (arg1)->shadowsizex = arg2;
14114 : resultobj = SWIG_Py_Void();
14115 0 : return resultobj;
14116 0 : fail:
14117 : return NULL;
14118 : }
14119 :
14120 :
14121 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14122 : PyObject *resultobj = 0;
14123 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14124 0 : void *argp1 = 0 ;
14125 : int res1 = 0 ;
14126 0 : PyObject * obj0 = 0 ;
14127 : int result;
14128 :
14129 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowsizex_get",&obj0)) SWIG_fail;
14130 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14131 0 : if (!SWIG_IsOK(res1)) {
14132 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizex_get" "', argument " "1"" of type '" "struct labelObj *""'");
14133 : }
14134 0 : arg1 = (struct labelObj *)(argp1);
14135 0 : result = (int) ((arg1)->shadowsizex);
14136 : resultobj = SWIG_From_int((int)(result));
14137 0 : return resultobj;
14138 0 : fail:
14139 : return NULL;
14140 : }
14141 :
14142 :
14143 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 : PyObject *resultobj = 0;
14145 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14146 : int arg2 ;
14147 0 : void *argp1 = 0 ;
14148 : int res1 = 0 ;
14149 : int val2 ;
14150 : int ecode2 = 0 ;
14151 0 : PyObject * obj0 = 0 ;
14152 0 : PyObject * obj1 = 0 ;
14153 :
14154 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_shadowsizey_set",&obj0,&obj1)) SWIG_fail;
14155 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14156 0 : if (!SWIG_IsOK(res1)) {
14157 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizey_set" "', argument " "1"" of type '" "struct labelObj *""'");
14158 : }
14159 0 : arg1 = (struct labelObj *)(argp1);
14160 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14161 0 : if (!SWIG_IsOK(ecode2)) {
14162 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_shadowsizey_set" "', argument " "2"" of type '" "int""'");
14163 : }
14164 : arg2 = (int)(val2);
14165 0 : if (arg1) (arg1)->shadowsizey = arg2;
14166 : resultobj = SWIG_Py_Void();
14167 0 : return resultobj;
14168 0 : fail:
14169 : return NULL;
14170 : }
14171 :
14172 :
14173 0 : SWIGINTERN PyObject *_wrap_labelObj_shadowsizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14174 : PyObject *resultobj = 0;
14175 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14176 0 : void *argp1 = 0 ;
14177 : int res1 = 0 ;
14178 0 : PyObject * obj0 = 0 ;
14179 : int result;
14180 :
14181 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_shadowsizey_get",&obj0)) SWIG_fail;
14182 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14183 0 : if (!SWIG_IsOK(res1)) {
14184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_shadowsizey_get" "', argument " "1"" of type '" "struct labelObj *""'");
14185 : }
14186 0 : arg1 = (struct labelObj *)(argp1);
14187 0 : result = (int) ((arg1)->shadowsizey);
14188 : resultobj = SWIG_From_int((int)(result));
14189 0 : return resultobj;
14190 0 : fail:
14191 : return NULL;
14192 : }
14193 :
14194 :
14195 1 : SWIGINTERN PyObject *_wrap_labelObj_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14196 : PyObject *resultobj = 0;
14197 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14198 : int arg2 ;
14199 1 : void *argp1 = 0 ;
14200 : int res1 = 0 ;
14201 : int val2 ;
14202 : int ecode2 = 0 ;
14203 1 : PyObject * obj0 = 0 ;
14204 1 : PyObject * obj1 = 0 ;
14205 :
14206 1 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_size_set",&obj0,&obj1)) SWIG_fail;
14207 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14208 1 : if (!SWIG_IsOK(res1)) {
14209 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_size_set" "', argument " "1"" of type '" "struct labelObj *""'");
14210 : }
14211 1 : arg1 = (struct labelObj *)(argp1);
14212 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14213 1 : if (!SWIG_IsOK(ecode2)) {
14214 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_size_set" "', argument " "2"" of type '" "int""'");
14215 : }
14216 : arg2 = (int)(val2);
14217 1 : if (arg1) (arg1)->size = arg2;
14218 : resultobj = SWIG_Py_Void();
14219 1 : return resultobj;
14220 0 : fail:
14221 : return NULL;
14222 : }
14223 :
14224 :
14225 0 : SWIGINTERN PyObject *_wrap_labelObj_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14226 : PyObject *resultobj = 0;
14227 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14228 0 : void *argp1 = 0 ;
14229 : int res1 = 0 ;
14230 0 : PyObject * obj0 = 0 ;
14231 : int result;
14232 :
14233 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_size_get",&obj0)) SWIG_fail;
14234 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14235 0 : if (!SWIG_IsOK(res1)) {
14236 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_size_get" "', argument " "1"" of type '" "struct labelObj *""'");
14237 : }
14238 0 : arg1 = (struct labelObj *)(argp1);
14239 0 : result = (int) ((arg1)->size);
14240 : resultobj = SWIG_From_int((int)(result));
14241 0 : return resultobj;
14242 0 : fail:
14243 : return NULL;
14244 : }
14245 :
14246 :
14247 0 : SWIGINTERN PyObject *_wrap_labelObj_minsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14248 : PyObject *resultobj = 0;
14249 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14250 : int arg2 ;
14251 0 : void *argp1 = 0 ;
14252 : int res1 = 0 ;
14253 : int val2 ;
14254 : int ecode2 = 0 ;
14255 0 : PyObject * obj0 = 0 ;
14256 0 : PyObject * obj1 = 0 ;
14257 :
14258 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minsize_set",&obj0,&obj1)) SWIG_fail;
14259 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14260 0 : if (!SWIG_IsOK(res1)) {
14261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minsize_set" "', argument " "1"" of type '" "struct labelObj *""'");
14262 : }
14263 0 : arg1 = (struct labelObj *)(argp1);
14264 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14265 0 : if (!SWIG_IsOK(ecode2)) {
14266 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minsize_set" "', argument " "2"" of type '" "int""'");
14267 : }
14268 : arg2 = (int)(val2);
14269 0 : if (arg1) (arg1)->minsize = arg2;
14270 : resultobj = SWIG_Py_Void();
14271 0 : return resultobj;
14272 0 : fail:
14273 : return NULL;
14274 : }
14275 :
14276 :
14277 0 : SWIGINTERN PyObject *_wrap_labelObj_minsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14278 : PyObject *resultobj = 0;
14279 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14280 0 : void *argp1 = 0 ;
14281 : int res1 = 0 ;
14282 0 : PyObject * obj0 = 0 ;
14283 : int result;
14284 :
14285 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minsize_get",&obj0)) SWIG_fail;
14286 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14287 0 : if (!SWIG_IsOK(res1)) {
14288 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minsize_get" "', argument " "1"" of type '" "struct labelObj *""'");
14289 : }
14290 0 : arg1 = (struct labelObj *)(argp1);
14291 0 : result = (int) ((arg1)->minsize);
14292 : resultobj = SWIG_From_int((int)(result));
14293 0 : return resultobj;
14294 0 : fail:
14295 : return NULL;
14296 : }
14297 :
14298 :
14299 0 : SWIGINTERN PyObject *_wrap_labelObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14300 : PyObject *resultobj = 0;
14301 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14302 : int arg2 ;
14303 0 : void *argp1 = 0 ;
14304 : int res1 = 0 ;
14305 : int val2 ;
14306 : int ecode2 = 0 ;
14307 0 : PyObject * obj0 = 0 ;
14308 0 : PyObject * obj1 = 0 ;
14309 :
14310 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
14311 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14312 0 : if (!SWIG_IsOK(res1)) {
14313 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxsize_set" "', argument " "1"" of type '" "struct labelObj *""'");
14314 : }
14315 0 : arg1 = (struct labelObj *)(argp1);
14316 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14317 0 : if (!SWIG_IsOK(ecode2)) {
14318 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxsize_set" "', argument " "2"" of type '" "int""'");
14319 : }
14320 : arg2 = (int)(val2);
14321 0 : if (arg1) (arg1)->maxsize = arg2;
14322 : resultobj = SWIG_Py_Void();
14323 0 : return resultobj;
14324 0 : fail:
14325 : return NULL;
14326 : }
14327 :
14328 :
14329 0 : SWIGINTERN PyObject *_wrap_labelObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14330 : PyObject *resultobj = 0;
14331 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14332 0 : void *argp1 = 0 ;
14333 : int res1 = 0 ;
14334 0 : PyObject * obj0 = 0 ;
14335 : int result;
14336 :
14337 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxsize_get",&obj0)) SWIG_fail;
14338 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14339 0 : if (!SWIG_IsOK(res1)) {
14340 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxsize_get" "', argument " "1"" of type '" "struct labelObj *""'");
14341 : }
14342 0 : arg1 = (struct labelObj *)(argp1);
14343 0 : result = (int) ((arg1)->maxsize);
14344 : resultobj = SWIG_From_int((int)(result));
14345 0 : return resultobj;
14346 0 : fail:
14347 : return NULL;
14348 : }
14349 :
14350 :
14351 0 : SWIGINTERN PyObject *_wrap_labelObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14352 : PyObject *resultobj = 0;
14353 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14354 : int arg2 ;
14355 0 : void *argp1 = 0 ;
14356 : int res1 = 0 ;
14357 : int val2 ;
14358 : int ecode2 = 0 ;
14359 0 : PyObject * obj0 = 0 ;
14360 0 : PyObject * obj1 = 0 ;
14361 :
14362 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_position_set",&obj0,&obj1)) SWIG_fail;
14363 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14364 0 : if (!SWIG_IsOK(res1)) {
14365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_position_set" "', argument " "1"" of type '" "struct labelObj *""'");
14366 : }
14367 0 : arg1 = (struct labelObj *)(argp1);
14368 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14369 0 : if (!SWIG_IsOK(ecode2)) {
14370 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_position_set" "', argument " "2"" of type '" "int""'");
14371 : }
14372 : arg2 = (int)(val2);
14373 0 : if (arg1) (arg1)->position = arg2;
14374 : resultobj = SWIG_Py_Void();
14375 0 : return resultobj;
14376 0 : fail:
14377 : return NULL;
14378 : }
14379 :
14380 :
14381 0 : SWIGINTERN PyObject *_wrap_labelObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 : PyObject *resultobj = 0;
14383 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14384 0 : void *argp1 = 0 ;
14385 : int res1 = 0 ;
14386 0 : PyObject * obj0 = 0 ;
14387 : int result;
14388 :
14389 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_position_get",&obj0)) SWIG_fail;
14390 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14391 0 : if (!SWIG_IsOK(res1)) {
14392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_position_get" "', argument " "1"" of type '" "struct labelObj *""'");
14393 : }
14394 0 : arg1 = (struct labelObj *)(argp1);
14395 0 : result = (int) ((arg1)->position);
14396 : resultobj = SWIG_From_int((int)(result));
14397 0 : return resultobj;
14398 0 : fail:
14399 : return NULL;
14400 : }
14401 :
14402 :
14403 0 : SWIGINTERN PyObject *_wrap_labelObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14404 : PyObject *resultobj = 0;
14405 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14406 : int arg2 ;
14407 0 : void *argp1 = 0 ;
14408 : int res1 = 0 ;
14409 : int val2 ;
14410 : int ecode2 = 0 ;
14411 0 : PyObject * obj0 = 0 ;
14412 0 : PyObject * obj1 = 0 ;
14413 :
14414 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
14415 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14416 0 : if (!SWIG_IsOK(res1)) {
14417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsetx_set" "', argument " "1"" of type '" "struct labelObj *""'");
14418 : }
14419 0 : arg1 = (struct labelObj *)(argp1);
14420 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14421 0 : if (!SWIG_IsOK(ecode2)) {
14422 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_offsetx_set" "', argument " "2"" of type '" "int""'");
14423 : }
14424 : arg2 = (int)(val2);
14425 0 : if (arg1) (arg1)->offsetx = arg2;
14426 : resultobj = SWIG_Py_Void();
14427 0 : return resultobj;
14428 0 : fail:
14429 : return NULL;
14430 : }
14431 :
14432 :
14433 0 : SWIGINTERN PyObject *_wrap_labelObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14434 : PyObject *resultobj = 0;
14435 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14436 0 : void *argp1 = 0 ;
14437 : int res1 = 0 ;
14438 0 : PyObject * obj0 = 0 ;
14439 : int result;
14440 :
14441 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_offsetx_get",&obj0)) SWIG_fail;
14442 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14443 0 : if (!SWIG_IsOK(res1)) {
14444 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsetx_get" "', argument " "1"" of type '" "struct labelObj *""'");
14445 : }
14446 0 : arg1 = (struct labelObj *)(argp1);
14447 0 : result = (int) ((arg1)->offsetx);
14448 : resultobj = SWIG_From_int((int)(result));
14449 0 : return resultobj;
14450 0 : fail:
14451 : return NULL;
14452 : }
14453 :
14454 :
14455 0 : SWIGINTERN PyObject *_wrap_labelObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14456 : PyObject *resultobj = 0;
14457 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14458 : int arg2 ;
14459 0 : void *argp1 = 0 ;
14460 : int res1 = 0 ;
14461 : int val2 ;
14462 : int ecode2 = 0 ;
14463 0 : PyObject * obj0 = 0 ;
14464 0 : PyObject * obj1 = 0 ;
14465 :
14466 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_offsety_set",&obj0,&obj1)) SWIG_fail;
14467 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14468 0 : if (!SWIG_IsOK(res1)) {
14469 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsety_set" "', argument " "1"" of type '" "struct labelObj *""'");
14470 : }
14471 0 : arg1 = (struct labelObj *)(argp1);
14472 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14473 0 : if (!SWIG_IsOK(ecode2)) {
14474 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_offsety_set" "', argument " "2"" of type '" "int""'");
14475 : }
14476 : arg2 = (int)(val2);
14477 0 : if (arg1) (arg1)->offsety = arg2;
14478 : resultobj = SWIG_Py_Void();
14479 0 : return resultobj;
14480 0 : fail:
14481 : return NULL;
14482 : }
14483 :
14484 :
14485 0 : SWIGINTERN PyObject *_wrap_labelObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14486 : PyObject *resultobj = 0;
14487 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14488 0 : void *argp1 = 0 ;
14489 : int res1 = 0 ;
14490 0 : PyObject * obj0 = 0 ;
14491 : int result;
14492 :
14493 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_offsety_get",&obj0)) SWIG_fail;
14494 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14495 0 : if (!SWIG_IsOK(res1)) {
14496 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_offsety_get" "', argument " "1"" of type '" "struct labelObj *""'");
14497 : }
14498 0 : arg1 = (struct labelObj *)(argp1);
14499 0 : result = (int) ((arg1)->offsety);
14500 : resultobj = SWIG_From_int((int)(result));
14501 0 : return resultobj;
14502 0 : fail:
14503 : return NULL;
14504 : }
14505 :
14506 :
14507 0 : SWIGINTERN PyObject *_wrap_labelObj_angle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14508 : PyObject *resultobj = 0;
14509 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14510 : double arg2 ;
14511 0 : void *argp1 = 0 ;
14512 : int res1 = 0 ;
14513 : double val2 ;
14514 : int ecode2 = 0 ;
14515 0 : PyObject * obj0 = 0 ;
14516 0 : PyObject * obj1 = 0 ;
14517 :
14518 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_angle_set",&obj0,&obj1)) SWIG_fail;
14519 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14520 0 : if (!SWIG_IsOK(res1)) {
14521 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_angle_set" "', argument " "1"" of type '" "struct labelObj *""'");
14522 : }
14523 0 : arg1 = (struct labelObj *)(argp1);
14524 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
14525 0 : if (!SWIG_IsOK(ecode2)) {
14526 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_angle_set" "', argument " "2"" of type '" "double""'");
14527 : }
14528 0 : arg2 = (double)(val2);
14529 0 : if (arg1) (arg1)->angle = arg2;
14530 : resultobj = SWIG_Py_Void();
14531 0 : return resultobj;
14532 0 : fail:
14533 : return NULL;
14534 : }
14535 :
14536 :
14537 0 : SWIGINTERN PyObject *_wrap_labelObj_angle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14538 : PyObject *resultobj = 0;
14539 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14540 0 : void *argp1 = 0 ;
14541 : int res1 = 0 ;
14542 0 : PyObject * obj0 = 0 ;
14543 : double result;
14544 :
14545 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_angle_get",&obj0)) SWIG_fail;
14546 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14547 0 : if (!SWIG_IsOK(res1)) {
14548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_angle_get" "', argument " "1"" of type '" "struct labelObj *""'");
14549 : }
14550 0 : arg1 = (struct labelObj *)(argp1);
14551 0 : result = (double) ((arg1)->angle);
14552 0 : resultobj = SWIG_From_double((double)(result));
14553 0 : return resultobj;
14554 0 : fail:
14555 : return NULL;
14556 : }
14557 :
14558 :
14559 0 : SWIGINTERN PyObject *_wrap_labelObj_anglemode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14560 : PyObject *resultobj = 0;
14561 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14562 : enum MS_POSITIONS_ENUM arg2 ;
14563 0 : void *argp1 = 0 ;
14564 : int res1 = 0 ;
14565 : int val2 ;
14566 : int ecode2 = 0 ;
14567 0 : PyObject * obj0 = 0 ;
14568 0 : PyObject * obj1 = 0 ;
14569 :
14570 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_anglemode_set",&obj0,&obj1)) SWIG_fail;
14571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14572 0 : if (!SWIG_IsOK(res1)) {
14573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_anglemode_set" "', argument " "1"" of type '" "struct labelObj *""'");
14574 : }
14575 0 : arg1 = (struct labelObj *)(argp1);
14576 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14577 0 : if (!SWIG_IsOK(ecode2)) {
14578 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_anglemode_set" "', argument " "2"" of type '" "enum MS_POSITIONS_ENUM""'");
14579 : }
14580 0 : arg2 = (enum MS_POSITIONS_ENUM)(val2);
14581 0 : if (arg1) (arg1)->anglemode = arg2;
14582 : resultobj = SWIG_Py_Void();
14583 0 : return resultobj;
14584 0 : fail:
14585 : return NULL;
14586 : }
14587 :
14588 :
14589 0 : SWIGINTERN PyObject *_wrap_labelObj_anglemode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14590 : PyObject *resultobj = 0;
14591 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14592 0 : void *argp1 = 0 ;
14593 : int res1 = 0 ;
14594 0 : PyObject * obj0 = 0 ;
14595 : enum MS_POSITIONS_ENUM result;
14596 :
14597 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_anglemode_get",&obj0)) SWIG_fail;
14598 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14599 0 : if (!SWIG_IsOK(res1)) {
14600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_anglemode_get" "', argument " "1"" of type '" "struct labelObj *""'");
14601 : }
14602 0 : arg1 = (struct labelObj *)(argp1);
14603 0 : result = (enum MS_POSITIONS_ENUM) ((arg1)->anglemode);
14604 0 : resultobj = SWIG_From_int((int)(result));
14605 0 : return resultobj;
14606 0 : fail:
14607 : return NULL;
14608 : }
14609 :
14610 :
14611 0 : SWIGINTERN PyObject *_wrap_labelObj_buffer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14612 : PyObject *resultobj = 0;
14613 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14614 : int arg2 ;
14615 0 : void *argp1 = 0 ;
14616 : int res1 = 0 ;
14617 : int val2 ;
14618 : int ecode2 = 0 ;
14619 0 : PyObject * obj0 = 0 ;
14620 0 : PyObject * obj1 = 0 ;
14621 :
14622 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_buffer_set",&obj0,&obj1)) SWIG_fail;
14623 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14624 0 : if (!SWIG_IsOK(res1)) {
14625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_buffer_set" "', argument " "1"" of type '" "struct labelObj *""'");
14626 : }
14627 0 : arg1 = (struct labelObj *)(argp1);
14628 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14629 0 : if (!SWIG_IsOK(ecode2)) {
14630 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_buffer_set" "', argument " "2"" of type '" "int""'");
14631 : }
14632 : arg2 = (int)(val2);
14633 0 : if (arg1) (arg1)->buffer = arg2;
14634 : resultobj = SWIG_Py_Void();
14635 0 : return resultobj;
14636 0 : fail:
14637 : return NULL;
14638 : }
14639 :
14640 :
14641 0 : SWIGINTERN PyObject *_wrap_labelObj_buffer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14642 : PyObject *resultobj = 0;
14643 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14644 0 : void *argp1 = 0 ;
14645 : int res1 = 0 ;
14646 0 : PyObject * obj0 = 0 ;
14647 : int result;
14648 :
14649 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_buffer_get",&obj0)) SWIG_fail;
14650 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14651 0 : if (!SWIG_IsOK(res1)) {
14652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_buffer_get" "', argument " "1"" of type '" "struct labelObj *""'");
14653 : }
14654 0 : arg1 = (struct labelObj *)(argp1);
14655 0 : result = (int) ((arg1)->buffer);
14656 : resultobj = SWIG_From_int((int)(result));
14657 0 : return resultobj;
14658 0 : fail:
14659 : return NULL;
14660 : }
14661 :
14662 :
14663 0 : SWIGINTERN PyObject *_wrap_labelObj_align_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14664 : PyObject *resultobj = 0;
14665 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14666 : int arg2 ;
14667 0 : void *argp1 = 0 ;
14668 : int res1 = 0 ;
14669 : int val2 ;
14670 : int ecode2 = 0 ;
14671 0 : PyObject * obj0 = 0 ;
14672 0 : PyObject * obj1 = 0 ;
14673 :
14674 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_align_set",&obj0,&obj1)) SWIG_fail;
14675 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14676 0 : if (!SWIG_IsOK(res1)) {
14677 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_align_set" "', argument " "1"" of type '" "struct labelObj *""'");
14678 : }
14679 0 : arg1 = (struct labelObj *)(argp1);
14680 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14681 0 : if (!SWIG_IsOK(ecode2)) {
14682 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_align_set" "', argument " "2"" of type '" "int""'");
14683 : }
14684 : arg2 = (int)(val2);
14685 0 : if (arg1) (arg1)->align = arg2;
14686 : resultobj = SWIG_Py_Void();
14687 0 : return resultobj;
14688 0 : fail:
14689 : return NULL;
14690 : }
14691 :
14692 :
14693 0 : SWIGINTERN PyObject *_wrap_labelObj_align_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14694 : PyObject *resultobj = 0;
14695 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14696 0 : void *argp1 = 0 ;
14697 : int res1 = 0 ;
14698 0 : PyObject * obj0 = 0 ;
14699 : int result;
14700 :
14701 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_align_get",&obj0)) SWIG_fail;
14702 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14703 0 : if (!SWIG_IsOK(res1)) {
14704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_align_get" "', argument " "1"" of type '" "struct labelObj *""'");
14705 : }
14706 0 : arg1 = (struct labelObj *)(argp1);
14707 0 : result = (int) ((arg1)->align);
14708 : resultobj = SWIG_From_int((int)(result));
14709 0 : return resultobj;
14710 0 : fail:
14711 : return NULL;
14712 : }
14713 :
14714 :
14715 0 : SWIGINTERN PyObject *_wrap_labelObj_wrap_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14716 : PyObject *resultobj = 0;
14717 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14718 : char arg2 ;
14719 0 : void *argp1 = 0 ;
14720 : int res1 = 0 ;
14721 : char val2 ;
14722 : int ecode2 = 0 ;
14723 0 : PyObject * obj0 = 0 ;
14724 0 : PyObject * obj1 = 0 ;
14725 :
14726 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_wrap_set",&obj0,&obj1)) SWIG_fail;
14727 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14728 0 : if (!SWIG_IsOK(res1)) {
14729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_wrap_set" "', argument " "1"" of type '" "struct labelObj *""'");
14730 : }
14731 0 : arg1 = (struct labelObj *)(argp1);
14732 0 : ecode2 = SWIG_AsVal_char(obj1, &val2);
14733 0 : if (!SWIG_IsOK(ecode2)) {
14734 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_wrap_set" "', argument " "2"" of type '" "char""'");
14735 : }
14736 0 : arg2 = (char)(val2);
14737 0 : if (arg1) (arg1)->wrap = arg2;
14738 : resultobj = SWIG_Py_Void();
14739 0 : return resultobj;
14740 0 : fail:
14741 : return NULL;
14742 : }
14743 :
14744 :
14745 0 : SWIGINTERN PyObject *_wrap_labelObj_wrap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14746 : PyObject *resultobj = 0;
14747 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14748 0 : void *argp1 = 0 ;
14749 : int res1 = 0 ;
14750 0 : PyObject * obj0 = 0 ;
14751 : char result;
14752 :
14753 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_wrap_get",&obj0)) SWIG_fail;
14754 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14755 0 : if (!SWIG_IsOK(res1)) {
14756 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_wrap_get" "', argument " "1"" of type '" "struct labelObj *""'");
14757 : }
14758 0 : arg1 = (struct labelObj *)(argp1);
14759 0 : result = (char) ((arg1)->wrap);
14760 : resultobj = SWIG_From_char((char)(result));
14761 0 : return resultobj;
14762 0 : fail:
14763 : return NULL;
14764 : }
14765 :
14766 :
14767 0 : SWIGINTERN PyObject *_wrap_labelObj_maxlength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14768 : PyObject *resultobj = 0;
14769 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14770 : int arg2 ;
14771 0 : void *argp1 = 0 ;
14772 : int res1 = 0 ;
14773 : int val2 ;
14774 : int ecode2 = 0 ;
14775 0 : PyObject * obj0 = 0 ;
14776 0 : PyObject * obj1 = 0 ;
14777 :
14778 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxlength_set",&obj0,&obj1)) SWIG_fail;
14779 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14780 0 : if (!SWIG_IsOK(res1)) {
14781 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxlength_set" "', argument " "1"" of type '" "struct labelObj *""'");
14782 : }
14783 0 : arg1 = (struct labelObj *)(argp1);
14784 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14785 0 : if (!SWIG_IsOK(ecode2)) {
14786 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxlength_set" "', argument " "2"" of type '" "int""'");
14787 : }
14788 : arg2 = (int)(val2);
14789 0 : if (arg1) (arg1)->maxlength = arg2;
14790 : resultobj = SWIG_Py_Void();
14791 0 : return resultobj;
14792 0 : fail:
14793 : return NULL;
14794 : }
14795 :
14796 :
14797 0 : SWIGINTERN PyObject *_wrap_labelObj_maxlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14798 : PyObject *resultobj = 0;
14799 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14800 0 : void *argp1 = 0 ;
14801 : int res1 = 0 ;
14802 0 : PyObject * obj0 = 0 ;
14803 : int result;
14804 :
14805 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxlength_get",&obj0)) SWIG_fail;
14806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14807 0 : if (!SWIG_IsOK(res1)) {
14808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxlength_get" "', argument " "1"" of type '" "struct labelObj *""'");
14809 : }
14810 0 : arg1 = (struct labelObj *)(argp1);
14811 0 : result = (int) ((arg1)->maxlength);
14812 : resultobj = SWIG_From_int((int)(result));
14813 0 : return resultobj;
14814 0 : fail:
14815 : return NULL;
14816 : }
14817 :
14818 :
14819 0 : SWIGINTERN PyObject *_wrap_labelObj_minlength_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14820 : PyObject *resultobj = 0;
14821 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14822 : int arg2 ;
14823 0 : void *argp1 = 0 ;
14824 : int res1 = 0 ;
14825 : int val2 ;
14826 : int ecode2 = 0 ;
14827 0 : PyObject * obj0 = 0 ;
14828 0 : PyObject * obj1 = 0 ;
14829 :
14830 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minlength_set",&obj0,&obj1)) SWIG_fail;
14831 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14832 0 : if (!SWIG_IsOK(res1)) {
14833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minlength_set" "', argument " "1"" of type '" "struct labelObj *""'");
14834 : }
14835 0 : arg1 = (struct labelObj *)(argp1);
14836 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14837 0 : if (!SWIG_IsOK(ecode2)) {
14838 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minlength_set" "', argument " "2"" of type '" "int""'");
14839 : }
14840 : arg2 = (int)(val2);
14841 0 : if (arg1) (arg1)->minlength = arg2;
14842 : resultobj = SWIG_Py_Void();
14843 0 : return resultobj;
14844 0 : fail:
14845 : return NULL;
14846 : }
14847 :
14848 :
14849 0 : SWIGINTERN PyObject *_wrap_labelObj_minlength_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14850 : PyObject *resultobj = 0;
14851 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14852 0 : void *argp1 = 0 ;
14853 : int res1 = 0 ;
14854 0 : PyObject * obj0 = 0 ;
14855 : int result;
14856 :
14857 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minlength_get",&obj0)) SWIG_fail;
14858 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14859 0 : if (!SWIG_IsOK(res1)) {
14860 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minlength_get" "', argument " "1"" of type '" "struct labelObj *""'");
14861 : }
14862 0 : arg1 = (struct labelObj *)(argp1);
14863 0 : result = (int) ((arg1)->minlength);
14864 : resultobj = SWIG_From_int((int)(result));
14865 0 : return resultobj;
14866 0 : fail:
14867 : return NULL;
14868 : }
14869 :
14870 :
14871 0 : SWIGINTERN PyObject *_wrap_labelObj_space_size_10_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14872 : PyObject *resultobj = 0;
14873 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14874 : double arg2 ;
14875 0 : void *argp1 = 0 ;
14876 : int res1 = 0 ;
14877 : double val2 ;
14878 : int ecode2 = 0 ;
14879 0 : PyObject * obj0 = 0 ;
14880 0 : PyObject * obj1 = 0 ;
14881 :
14882 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_space_size_10_set",&obj0,&obj1)) SWIG_fail;
14883 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14884 0 : if (!SWIG_IsOK(res1)) {
14885 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_space_size_10_set" "', argument " "1"" of type '" "struct labelObj *""'");
14886 : }
14887 0 : arg1 = (struct labelObj *)(argp1);
14888 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
14889 0 : if (!SWIG_IsOK(ecode2)) {
14890 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_space_size_10_set" "', argument " "2"" of type '" "double""'");
14891 : }
14892 0 : arg2 = (double)(val2);
14893 0 : if (arg1) (arg1)->space_size_10 = arg2;
14894 : resultobj = SWIG_Py_Void();
14895 0 : return resultobj;
14896 0 : fail:
14897 : return NULL;
14898 : }
14899 :
14900 :
14901 0 : SWIGINTERN PyObject *_wrap_labelObj_space_size_10_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14902 : PyObject *resultobj = 0;
14903 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14904 0 : void *argp1 = 0 ;
14905 : int res1 = 0 ;
14906 0 : PyObject * obj0 = 0 ;
14907 : double result;
14908 :
14909 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_space_size_10_get",&obj0)) SWIG_fail;
14910 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14911 0 : if (!SWIG_IsOK(res1)) {
14912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_space_size_10_get" "', argument " "1"" of type '" "struct labelObj *""'");
14913 : }
14914 0 : arg1 = (struct labelObj *)(argp1);
14915 0 : result = (double) ((arg1)->space_size_10);
14916 0 : resultobj = SWIG_From_double((double)(result));
14917 0 : return resultobj;
14918 0 : fail:
14919 : return NULL;
14920 : }
14921 :
14922 :
14923 0 : SWIGINTERN PyObject *_wrap_labelObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14924 : PyObject *resultobj = 0;
14925 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14926 : int arg2 ;
14927 0 : void *argp1 = 0 ;
14928 : int res1 = 0 ;
14929 : int val2 ;
14930 : int ecode2 = 0 ;
14931 0 : PyObject * obj0 = 0 ;
14932 0 : PyObject * obj1 = 0 ;
14933 :
14934 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
14935 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14936 0 : if (!SWIG_IsOK(res1)) {
14937 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minfeaturesize_set" "', argument " "1"" of type '" "struct labelObj *""'");
14938 : }
14939 0 : arg1 = (struct labelObj *)(argp1);
14940 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14941 0 : if (!SWIG_IsOK(ecode2)) {
14942 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
14943 : }
14944 : arg2 = (int)(val2);
14945 0 : if (arg1) (arg1)->minfeaturesize = arg2;
14946 : resultobj = SWIG_Py_Void();
14947 0 : return resultobj;
14948 0 : fail:
14949 : return NULL;
14950 : }
14951 :
14952 :
14953 0 : SWIGINTERN PyObject *_wrap_labelObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14954 : PyObject *resultobj = 0;
14955 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14956 0 : void *argp1 = 0 ;
14957 : int res1 = 0 ;
14958 0 : PyObject * obj0 = 0 ;
14959 : int result;
14960 :
14961 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minfeaturesize_get",&obj0)) SWIG_fail;
14962 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14963 0 : if (!SWIG_IsOK(res1)) {
14964 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minfeaturesize_get" "', argument " "1"" of type '" "struct labelObj *""'");
14965 : }
14966 0 : arg1 = (struct labelObj *)(argp1);
14967 0 : result = (int) ((arg1)->minfeaturesize);
14968 : resultobj = SWIG_From_int((int)(result));
14969 0 : return resultobj;
14970 0 : fail:
14971 : return NULL;
14972 : }
14973 :
14974 :
14975 0 : SWIGINTERN PyObject *_wrap_labelObj_autominfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14976 : PyObject *resultobj = 0;
14977 : struct labelObj *arg1 = (struct labelObj *) 0 ;
14978 : int arg2 ;
14979 0 : void *argp1 = 0 ;
14980 : int res1 = 0 ;
14981 : int val2 ;
14982 : int ecode2 = 0 ;
14983 0 : PyObject * obj0 = 0 ;
14984 0 : PyObject * obj1 = 0 ;
14985 :
14986 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_autominfeaturesize_set",&obj0,&obj1)) SWIG_fail;
14987 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
14988 0 : if (!SWIG_IsOK(res1)) {
14989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_autominfeaturesize_set" "', argument " "1"" of type '" "struct labelObj *""'");
14990 : }
14991 0 : arg1 = (struct labelObj *)(argp1);
14992 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14993 0 : if (!SWIG_IsOK(ecode2)) {
14994 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_autominfeaturesize_set" "', argument " "2"" of type '" "int""'");
14995 : }
14996 : arg2 = (int)(val2);
14997 0 : if (arg1) (arg1)->autominfeaturesize = arg2;
14998 : resultobj = SWIG_Py_Void();
14999 0 : return resultobj;
15000 0 : fail:
15001 : return NULL;
15002 : }
15003 :
15004 :
15005 0 : SWIGINTERN PyObject *_wrap_labelObj_autominfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15006 : PyObject *resultobj = 0;
15007 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15008 0 : void *argp1 = 0 ;
15009 : int res1 = 0 ;
15010 0 : PyObject * obj0 = 0 ;
15011 : int result;
15012 :
15013 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_autominfeaturesize_get",&obj0)) SWIG_fail;
15014 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15015 0 : if (!SWIG_IsOK(res1)) {
15016 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_autominfeaturesize_get" "', argument " "1"" of type '" "struct labelObj *""'");
15017 : }
15018 0 : arg1 = (struct labelObj *)(argp1);
15019 0 : result = (int) ((arg1)->autominfeaturesize);
15020 : resultobj = SWIG_From_int((int)(result));
15021 0 : return resultobj;
15022 0 : fail:
15023 : return NULL;
15024 : }
15025 :
15026 :
15027 0 : SWIGINTERN PyObject *_wrap_labelObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15028 : PyObject *resultobj = 0;
15029 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15030 : double arg2 ;
15031 0 : void *argp1 = 0 ;
15032 : int res1 = 0 ;
15033 : double val2 ;
15034 : int ecode2 = 0 ;
15035 0 : PyObject * obj0 = 0 ;
15036 0 : PyObject * obj1 = 0 ;
15037 :
15038 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
15039 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15040 0 : if (!SWIG_IsOK(res1)) {
15041 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minscaledenom_set" "', argument " "1"" of type '" "struct labelObj *""'");
15042 : }
15043 0 : arg1 = (struct labelObj *)(argp1);
15044 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
15045 0 : if (!SWIG_IsOK(ecode2)) {
15046 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
15047 : }
15048 0 : arg2 = (double)(val2);
15049 0 : if (arg1) (arg1)->minscaledenom = arg2;
15050 : resultobj = SWIG_Py_Void();
15051 0 : return resultobj;
15052 0 : fail:
15053 : return NULL;
15054 : }
15055 :
15056 :
15057 0 : SWIGINTERN PyObject *_wrap_labelObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15058 : PyObject *resultobj = 0;
15059 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15060 0 : void *argp1 = 0 ;
15061 : int res1 = 0 ;
15062 0 : PyObject * obj0 = 0 ;
15063 : double result;
15064 :
15065 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_minscaledenom_get",&obj0)) SWIG_fail;
15066 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15067 0 : if (!SWIG_IsOK(res1)) {
15068 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_minscaledenom_get" "', argument " "1"" of type '" "struct labelObj *""'");
15069 : }
15070 0 : arg1 = (struct labelObj *)(argp1);
15071 0 : result = (double) ((arg1)->minscaledenom);
15072 0 : resultobj = SWIG_From_double((double)(result));
15073 0 : return resultobj;
15074 0 : fail:
15075 : return NULL;
15076 : }
15077 :
15078 :
15079 0 : SWIGINTERN PyObject *_wrap_labelObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15080 : PyObject *resultobj = 0;
15081 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15082 : double arg2 ;
15083 0 : void *argp1 = 0 ;
15084 : int res1 = 0 ;
15085 : double val2 ;
15086 : int ecode2 = 0 ;
15087 0 : PyObject * obj0 = 0 ;
15088 0 : PyObject * obj1 = 0 ;
15089 :
15090 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
15091 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15092 0 : if (!SWIG_IsOK(res1)) {
15093 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxscaledenom_set" "', argument " "1"" of type '" "struct labelObj *""'");
15094 : }
15095 0 : arg1 = (struct labelObj *)(argp1);
15096 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
15097 0 : if (!SWIG_IsOK(ecode2)) {
15098 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
15099 : }
15100 0 : arg2 = (double)(val2);
15101 0 : if (arg1) (arg1)->maxscaledenom = arg2;
15102 : resultobj = SWIG_Py_Void();
15103 0 : return resultobj;
15104 0 : fail:
15105 : return NULL;
15106 : }
15107 :
15108 :
15109 0 : SWIGINTERN PyObject *_wrap_labelObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15110 : PyObject *resultobj = 0;
15111 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15112 0 : void *argp1 = 0 ;
15113 : int res1 = 0 ;
15114 0 : PyObject * obj0 = 0 ;
15115 : double result;
15116 :
15117 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxscaledenom_get",&obj0)) SWIG_fail;
15118 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15119 0 : if (!SWIG_IsOK(res1)) {
15120 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxscaledenom_get" "', argument " "1"" of type '" "struct labelObj *""'");
15121 : }
15122 0 : arg1 = (struct labelObj *)(argp1);
15123 0 : result = (double) ((arg1)->maxscaledenom);
15124 0 : resultobj = SWIG_From_double((double)(result));
15125 0 : return resultobj;
15126 0 : fail:
15127 : return NULL;
15128 : }
15129 :
15130 :
15131 0 : SWIGINTERN PyObject *_wrap_labelObj_mindistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15132 : PyObject *resultobj = 0;
15133 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15134 : int arg2 ;
15135 0 : void *argp1 = 0 ;
15136 : int res1 = 0 ;
15137 : int val2 ;
15138 : int ecode2 = 0 ;
15139 0 : PyObject * obj0 = 0 ;
15140 0 : PyObject * obj1 = 0 ;
15141 :
15142 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_mindistance_set",&obj0,&obj1)) SWIG_fail;
15143 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15144 0 : if (!SWIG_IsOK(res1)) {
15145 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_mindistance_set" "', argument " "1"" of type '" "struct labelObj *""'");
15146 : }
15147 0 : arg1 = (struct labelObj *)(argp1);
15148 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15149 0 : if (!SWIG_IsOK(ecode2)) {
15150 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_mindistance_set" "', argument " "2"" of type '" "int""'");
15151 : }
15152 : arg2 = (int)(val2);
15153 0 : if (arg1) (arg1)->mindistance = arg2;
15154 : resultobj = SWIG_Py_Void();
15155 0 : return resultobj;
15156 0 : fail:
15157 : return NULL;
15158 : }
15159 :
15160 :
15161 0 : SWIGINTERN PyObject *_wrap_labelObj_mindistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15162 : PyObject *resultobj = 0;
15163 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15164 0 : void *argp1 = 0 ;
15165 : int res1 = 0 ;
15166 0 : PyObject * obj0 = 0 ;
15167 : int result;
15168 :
15169 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_mindistance_get",&obj0)) SWIG_fail;
15170 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15171 0 : if (!SWIG_IsOK(res1)) {
15172 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_mindistance_get" "', argument " "1"" of type '" "struct labelObj *""'");
15173 : }
15174 0 : arg1 = (struct labelObj *)(argp1);
15175 0 : result = (int) ((arg1)->mindistance);
15176 : resultobj = SWIG_From_int((int)(result));
15177 0 : return resultobj;
15178 0 : fail:
15179 : return NULL;
15180 : }
15181 :
15182 :
15183 0 : SWIGINTERN PyObject *_wrap_labelObj_repeatdistance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15184 : PyObject *resultobj = 0;
15185 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15186 : int arg2 ;
15187 0 : void *argp1 = 0 ;
15188 : int res1 = 0 ;
15189 : int val2 ;
15190 : int ecode2 = 0 ;
15191 0 : PyObject * obj0 = 0 ;
15192 0 : PyObject * obj1 = 0 ;
15193 :
15194 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_repeatdistance_set",&obj0,&obj1)) SWIG_fail;
15195 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15196 0 : if (!SWIG_IsOK(res1)) {
15197 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_repeatdistance_set" "', argument " "1"" of type '" "struct labelObj *""'");
15198 : }
15199 0 : arg1 = (struct labelObj *)(argp1);
15200 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15201 0 : if (!SWIG_IsOK(ecode2)) {
15202 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_repeatdistance_set" "', argument " "2"" of type '" "int""'");
15203 : }
15204 : arg2 = (int)(val2);
15205 0 : if (arg1) (arg1)->repeatdistance = arg2;
15206 : resultobj = SWIG_Py_Void();
15207 0 : return resultobj;
15208 0 : fail:
15209 : return NULL;
15210 : }
15211 :
15212 :
15213 0 : SWIGINTERN PyObject *_wrap_labelObj_repeatdistance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15214 : PyObject *resultobj = 0;
15215 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15216 0 : void *argp1 = 0 ;
15217 : int res1 = 0 ;
15218 0 : PyObject * obj0 = 0 ;
15219 : int result;
15220 :
15221 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_repeatdistance_get",&obj0)) SWIG_fail;
15222 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15223 0 : if (!SWIG_IsOK(res1)) {
15224 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_repeatdistance_get" "', argument " "1"" of type '" "struct labelObj *""'");
15225 : }
15226 0 : arg1 = (struct labelObj *)(argp1);
15227 0 : result = (int) ((arg1)->repeatdistance);
15228 : resultobj = SWIG_From_int((int)(result));
15229 0 : return resultobj;
15230 0 : fail:
15231 : return NULL;
15232 : }
15233 :
15234 :
15235 0 : SWIGINTERN PyObject *_wrap_labelObj_maxoverlapangle_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15236 : PyObject *resultobj = 0;
15237 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15238 : double arg2 ;
15239 0 : void *argp1 = 0 ;
15240 : int res1 = 0 ;
15241 : double val2 ;
15242 : int ecode2 = 0 ;
15243 0 : PyObject * obj0 = 0 ;
15244 0 : PyObject * obj1 = 0 ;
15245 :
15246 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_maxoverlapangle_set",&obj0,&obj1)) SWIG_fail;
15247 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15248 0 : if (!SWIG_IsOK(res1)) {
15249 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxoverlapangle_set" "', argument " "1"" of type '" "struct labelObj *""'");
15250 : }
15251 0 : arg1 = (struct labelObj *)(argp1);
15252 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
15253 0 : if (!SWIG_IsOK(ecode2)) {
15254 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_maxoverlapangle_set" "', argument " "2"" of type '" "double""'");
15255 : }
15256 0 : arg2 = (double)(val2);
15257 0 : if (arg1) (arg1)->maxoverlapangle = arg2;
15258 : resultobj = SWIG_Py_Void();
15259 0 : return resultobj;
15260 0 : fail:
15261 : return NULL;
15262 : }
15263 :
15264 :
15265 0 : SWIGINTERN PyObject *_wrap_labelObj_maxoverlapangle_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15266 : PyObject *resultobj = 0;
15267 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15268 0 : void *argp1 = 0 ;
15269 : int res1 = 0 ;
15270 0 : PyObject * obj0 = 0 ;
15271 : double result;
15272 :
15273 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_maxoverlapangle_get",&obj0)) SWIG_fail;
15274 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15275 0 : if (!SWIG_IsOK(res1)) {
15276 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_maxoverlapangle_get" "', argument " "1"" of type '" "struct labelObj *""'");
15277 : }
15278 0 : arg1 = (struct labelObj *)(argp1);
15279 0 : result = (double) ((arg1)->maxoverlapangle);
15280 0 : resultobj = SWIG_From_double((double)(result));
15281 0 : return resultobj;
15282 0 : fail:
15283 : return NULL;
15284 : }
15285 :
15286 :
15287 0 : SWIGINTERN PyObject *_wrap_labelObj_partials_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15288 : PyObject *resultobj = 0;
15289 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15290 : int arg2 ;
15291 0 : void *argp1 = 0 ;
15292 : int res1 = 0 ;
15293 : int val2 ;
15294 : int ecode2 = 0 ;
15295 0 : PyObject * obj0 = 0 ;
15296 0 : PyObject * obj1 = 0 ;
15297 :
15298 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_partials_set",&obj0,&obj1)) SWIG_fail;
15299 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15300 0 : if (!SWIG_IsOK(res1)) {
15301 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_partials_set" "', argument " "1"" of type '" "struct labelObj *""'");
15302 : }
15303 0 : arg1 = (struct labelObj *)(argp1);
15304 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15305 0 : if (!SWIG_IsOK(ecode2)) {
15306 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_partials_set" "', argument " "2"" of type '" "int""'");
15307 : }
15308 : arg2 = (int)(val2);
15309 0 : if (arg1) (arg1)->partials = arg2;
15310 : resultobj = SWIG_Py_Void();
15311 0 : return resultobj;
15312 0 : fail:
15313 : return NULL;
15314 : }
15315 :
15316 :
15317 0 : SWIGINTERN PyObject *_wrap_labelObj_partials_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15318 : PyObject *resultobj = 0;
15319 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15320 0 : void *argp1 = 0 ;
15321 : int res1 = 0 ;
15322 0 : PyObject * obj0 = 0 ;
15323 : int result;
15324 :
15325 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_partials_get",&obj0)) SWIG_fail;
15326 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15327 0 : if (!SWIG_IsOK(res1)) {
15328 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_partials_get" "', argument " "1"" of type '" "struct labelObj *""'");
15329 : }
15330 0 : arg1 = (struct labelObj *)(argp1);
15331 0 : result = (int) ((arg1)->partials);
15332 : resultobj = SWIG_From_int((int)(result));
15333 0 : return resultobj;
15334 0 : fail:
15335 : return NULL;
15336 : }
15337 :
15338 :
15339 0 : SWIGINTERN PyObject *_wrap_labelObj_force_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15340 : PyObject *resultobj = 0;
15341 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15342 : int arg2 ;
15343 0 : void *argp1 = 0 ;
15344 : int res1 = 0 ;
15345 : int val2 ;
15346 : int ecode2 = 0 ;
15347 0 : PyObject * obj0 = 0 ;
15348 0 : PyObject * obj1 = 0 ;
15349 :
15350 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_force_set",&obj0,&obj1)) SWIG_fail;
15351 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15352 0 : if (!SWIG_IsOK(res1)) {
15353 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_force_set" "', argument " "1"" of type '" "struct labelObj *""'");
15354 : }
15355 0 : arg1 = (struct labelObj *)(argp1);
15356 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15357 0 : if (!SWIG_IsOK(ecode2)) {
15358 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_force_set" "', argument " "2"" of type '" "int""'");
15359 : }
15360 : arg2 = (int)(val2);
15361 0 : if (arg1) (arg1)->force = arg2;
15362 : resultobj = SWIG_Py_Void();
15363 0 : return resultobj;
15364 0 : fail:
15365 : return NULL;
15366 : }
15367 :
15368 :
15369 0 : SWIGINTERN PyObject *_wrap_labelObj_force_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15370 : PyObject *resultobj = 0;
15371 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15372 0 : void *argp1 = 0 ;
15373 : int res1 = 0 ;
15374 0 : PyObject * obj0 = 0 ;
15375 : int result;
15376 :
15377 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_force_get",&obj0)) SWIG_fail;
15378 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15379 0 : if (!SWIG_IsOK(res1)) {
15380 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_force_get" "', argument " "1"" of type '" "struct labelObj *""'");
15381 : }
15382 0 : arg1 = (struct labelObj *)(argp1);
15383 0 : result = (int) ((arg1)->force);
15384 : resultobj = SWIG_From_int((int)(result));
15385 0 : return resultobj;
15386 0 : fail:
15387 : return NULL;
15388 : }
15389 :
15390 :
15391 0 : SWIGINTERN PyObject *_wrap_labelObj_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15392 : PyObject *resultobj = 0;
15393 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15394 : char *arg2 = (char *) 0 ;
15395 0 : void *argp1 = 0 ;
15396 : int res1 = 0 ;
15397 : int res2 ;
15398 0 : char *buf2 = 0 ;
15399 0 : int alloc2 = 0 ;
15400 0 : PyObject * obj0 = 0 ;
15401 0 : PyObject * obj1 = 0 ;
15402 :
15403 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_encoding_set",&obj0,&obj1)) SWIG_fail;
15404 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15405 0 : if (!SWIG_IsOK(res1)) {
15406 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_encoding_set" "', argument " "1"" of type '" "struct labelObj *""'");
15407 : }
15408 0 : arg1 = (struct labelObj *)(argp1);
15409 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15410 0 : if (!SWIG_IsOK(res2)) {
15411 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_encoding_set" "', argument " "2"" of type '" "char *""'");
15412 : }
15413 0 : arg2 = (char *)(buf2);
15414 : {
15415 0 : if (arg1->encoding) free((char*)arg1->encoding);
15416 0 : if (arg2) {
15417 0 : arg1->encoding = (char *) malloc(strlen(arg2)+1);
15418 : strcpy((char*)arg1->encoding,arg2);
15419 : } else {
15420 0 : arg1->encoding = 0;
15421 : }
15422 : }
15423 : resultobj = SWIG_Py_Void();
15424 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15425 : return resultobj;
15426 0 : fail:
15427 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15428 : return NULL;
15429 : }
15430 :
15431 :
15432 0 : SWIGINTERN PyObject *_wrap_labelObj_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15433 : PyObject *resultobj = 0;
15434 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15435 0 : void *argp1 = 0 ;
15436 : int res1 = 0 ;
15437 0 : PyObject * obj0 = 0 ;
15438 : char *result = 0 ;
15439 :
15440 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_encoding_get",&obj0)) SWIG_fail;
15441 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15442 0 : if (!SWIG_IsOK(res1)) {
15443 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_encoding_get" "', argument " "1"" of type '" "struct labelObj *""'");
15444 : }
15445 0 : arg1 = (struct labelObj *)(argp1);
15446 0 : result = (char *) ((arg1)->encoding);
15447 0 : resultobj = SWIG_FromCharPtr((const char *)result);
15448 0 : return resultobj;
15449 0 : fail:
15450 : return NULL;
15451 : }
15452 :
15453 :
15454 0 : SWIGINTERN PyObject *_wrap_labelObj_priority_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15455 : PyObject *resultobj = 0;
15456 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15457 : int arg2 ;
15458 0 : void *argp1 = 0 ;
15459 : int res1 = 0 ;
15460 : int val2 ;
15461 : int ecode2 = 0 ;
15462 0 : PyObject * obj0 = 0 ;
15463 0 : PyObject * obj1 = 0 ;
15464 :
15465 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_priority_set",&obj0,&obj1)) SWIG_fail;
15466 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15467 0 : if (!SWIG_IsOK(res1)) {
15468 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_priority_set" "', argument " "1"" of type '" "struct labelObj *""'");
15469 : }
15470 0 : arg1 = (struct labelObj *)(argp1);
15471 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15472 0 : if (!SWIG_IsOK(ecode2)) {
15473 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_priority_set" "', argument " "2"" of type '" "int""'");
15474 : }
15475 : arg2 = (int)(val2);
15476 0 : if (arg1) (arg1)->priority = arg2;
15477 : resultobj = SWIG_Py_Void();
15478 0 : return resultobj;
15479 0 : fail:
15480 : return NULL;
15481 : }
15482 :
15483 :
15484 0 : SWIGINTERN PyObject *_wrap_labelObj_priority_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15485 : PyObject *resultobj = 0;
15486 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15487 0 : void *argp1 = 0 ;
15488 : int res1 = 0 ;
15489 0 : PyObject * obj0 = 0 ;
15490 : int result;
15491 :
15492 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_priority_get",&obj0)) SWIG_fail;
15493 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15494 0 : if (!SWIG_IsOK(res1)) {
15495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_priority_get" "', argument " "1"" of type '" "struct labelObj *""'");
15496 : }
15497 0 : arg1 = (struct labelObj *)(argp1);
15498 0 : result = (int) ((arg1)->priority);
15499 : resultobj = SWIG_From_int((int)(result));
15500 0 : return resultobj;
15501 0 : fail:
15502 : return NULL;
15503 : }
15504 :
15505 :
15506 0 : SWIGINTERN PyObject *_wrap_labelObj_numstyles_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15507 : PyObject *resultobj = 0;
15508 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15509 : int arg2 ;
15510 0 : void *argp1 = 0 ;
15511 : int res1 = 0 ;
15512 : int val2 ;
15513 : int ecode2 = 0 ;
15514 0 : PyObject * obj0 = 0 ;
15515 0 : PyObject * obj1 = 0 ;
15516 :
15517 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_numstyles_set",&obj0,&obj1)) SWIG_fail;
15518 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15519 0 : if (!SWIG_IsOK(res1)) {
15520 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_numstyles_set" "', argument " "1"" of type '" "struct labelObj *""'");
15521 : }
15522 0 : arg1 = (struct labelObj *)(argp1);
15523 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15524 0 : if (!SWIG_IsOK(ecode2)) {
15525 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_numstyles_set" "', argument " "2"" of type '" "int""'");
15526 : }
15527 : arg2 = (int)(val2);
15528 0 : if (arg1) (arg1)->numstyles = arg2;
15529 : resultobj = SWIG_Py_Void();
15530 0 : return resultobj;
15531 0 : fail:
15532 : return NULL;
15533 : }
15534 :
15535 :
15536 0 : SWIGINTERN PyObject *_wrap_labelObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15537 : PyObject *resultobj = 0;
15538 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15539 0 : void *argp1 = 0 ;
15540 : int res1 = 0 ;
15541 0 : PyObject * obj0 = 0 ;
15542 : int result;
15543 :
15544 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_numstyles_get",&obj0)) SWIG_fail;
15545 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15546 0 : if (!SWIG_IsOK(res1)) {
15547 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_numstyles_get" "', argument " "1"" of type '" "struct labelObj *""'");
15548 : }
15549 0 : arg1 = (struct labelObj *)(argp1);
15550 0 : result = (int) ((arg1)->numstyles);
15551 : resultobj = SWIG_From_int((int)(result));
15552 0 : return resultobj;
15553 0 : fail:
15554 : return NULL;
15555 : }
15556 :
15557 :
15558 0 : SWIGINTERN PyObject *_wrap_labelObj_leader_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15559 : PyObject *resultobj = 0;
15560 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15561 : labelLeaderObj *arg2 = (labelLeaderObj *) 0 ;
15562 0 : void *argp1 = 0 ;
15563 : int res1 = 0 ;
15564 0 : void *argp2 = 0 ;
15565 : int res2 = 0 ;
15566 0 : PyObject * obj0 = 0 ;
15567 0 : PyObject * obj1 = 0 ;
15568 :
15569 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_leader_set",&obj0,&obj1)) SWIG_fail;
15570 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15571 0 : if (!SWIG_IsOK(res1)) {
15572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_leader_set" "', argument " "1"" of type '" "struct labelObj *""'");
15573 : }
15574 0 : arg1 = (struct labelObj *)(argp1);
15575 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelLeaderObj, SWIG_POINTER_DISOWN | 0 );
15576 0 : if (!SWIG_IsOK(res2)) {
15577 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_leader_set" "', argument " "2"" of type '" "labelLeaderObj *""'");
15578 : }
15579 0 : arg2 = (labelLeaderObj *)(argp2);
15580 0 : if (arg1) (arg1)->leader = arg2;
15581 : resultobj = SWIG_Py_Void();
15582 0 : return resultobj;
15583 0 : fail:
15584 : return NULL;
15585 : }
15586 :
15587 :
15588 0 : SWIGINTERN PyObject *_wrap_labelObj_leader_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 : PyObject *resultobj = 0;
15590 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15591 0 : void *argp1 = 0 ;
15592 : int res1 = 0 ;
15593 0 : PyObject * obj0 = 0 ;
15594 : labelLeaderObj *result = 0 ;
15595 :
15596 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_leader_get",&obj0)) SWIG_fail;
15597 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15598 0 : if (!SWIG_IsOK(res1)) {
15599 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_leader_get" "', argument " "1"" of type '" "struct labelObj *""'");
15600 : }
15601 0 : arg1 = (struct labelObj *)(argp1);
15602 0 : result = (labelLeaderObj *) ((arg1)->leader);
15603 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, 0 | 0 );
15604 0 : return resultobj;
15605 0 : fail:
15606 : return NULL;
15607 : }
15608 :
15609 :
15610 0 : SWIGINTERN PyObject *_wrap_labelObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15611 : PyObject *resultobj = 0;
15612 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15613 : int arg2 ;
15614 0 : void *argp1 = 0 ;
15615 : int res1 = 0 ;
15616 : int val2 ;
15617 : int ecode2 = 0 ;
15618 0 : PyObject * obj0 = 0 ;
15619 0 : PyObject * obj1 = 0 ;
15620 :
15621 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
15622 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15623 0 : if (!SWIG_IsOK(res1)) {
15624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_sizeunits_set" "', argument " "1"" of type '" "struct labelObj *""'");
15625 : }
15626 0 : arg1 = (struct labelObj *)(argp1);
15627 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15628 0 : if (!SWIG_IsOK(ecode2)) {
15629 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
15630 : }
15631 : arg2 = (int)(val2);
15632 0 : if (arg1) (arg1)->sizeunits = arg2;
15633 : resultobj = SWIG_Py_Void();
15634 0 : return resultobj;
15635 0 : fail:
15636 : return NULL;
15637 : }
15638 :
15639 :
15640 0 : SWIGINTERN PyObject *_wrap_labelObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15641 : PyObject *resultobj = 0;
15642 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15643 0 : void *argp1 = 0 ;
15644 : int res1 = 0 ;
15645 0 : PyObject * obj0 = 0 ;
15646 : int result;
15647 :
15648 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_sizeunits_get",&obj0)) SWIG_fail;
15649 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15650 0 : if (!SWIG_IsOK(res1)) {
15651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_sizeunits_get" "', argument " "1"" of type '" "struct labelObj *""'");
15652 : }
15653 0 : arg1 = (struct labelObj *)(argp1);
15654 0 : result = (int) ((arg1)->sizeunits);
15655 : resultobj = SWIG_From_int((int)(result));
15656 0 : return resultobj;
15657 0 : fail:
15658 : return NULL;
15659 : }
15660 :
15661 :
15662 1 : SWIGINTERN PyObject *_wrap_new_labelObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15663 : PyObject *resultobj = 0;
15664 : struct labelObj *result = 0 ;
15665 :
15666 1 : if (!PyArg_ParseTuple(args,(char *)":new_labelObj")) SWIG_fail;
15667 : {
15668 1 : result = (struct labelObj *)new_labelObj(); {
15669 1 : errorObj *ms_error = msGetErrorObj();
15670 :
15671 1 : switch(ms_error->code) {
15672 : case MS_NOERR:
15673 : break;
15674 0 : case MS_NOTFOUND:
15675 0 : msResetErrorList();
15676 0 : break;
15677 : case -1:
15678 : break;
15679 0 : case MS_IOERR:
15680 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15681 0 : _raise_ms_exception();
15682 0 : msResetErrorList();
15683 0 : return NULL;
15684 : }
15685 : default:
15686 0 : _raise_ms_exception();
15687 0 : msResetErrorList();
15688 0 : return NULL;
15689 : }
15690 :
15691 : }
15692 : }
15693 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_NEW | 0 );
15694 1 : return resultobj;
15695 1 : fail:
15696 : return NULL;
15697 : }
15698 :
15699 :
15700 1 : SWIGINTERN PyObject *_wrap_delete_labelObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15701 : PyObject *resultobj = 0;
15702 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15703 1 : void *argp1 = 0 ;
15704 : int res1 = 0 ;
15705 1 : PyObject * obj0 = 0 ;
15706 :
15707 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_labelObj",&obj0)) SWIG_fail;
15708 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, SWIG_POINTER_DISOWN | 0 );
15709 1 : if (!SWIG_IsOK(res1)) {
15710 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelObj" "', argument " "1"" of type '" "struct labelObj *""'");
15711 : }
15712 1 : arg1 = (struct labelObj *)(argp1);
15713 : {
15714 : delete_labelObj(arg1); {
15715 1 : errorObj *ms_error = msGetErrorObj();
15716 :
15717 1 : switch(ms_error->code) {
15718 : case MS_NOERR:
15719 : break;
15720 0 : case MS_NOTFOUND:
15721 0 : msResetErrorList();
15722 0 : break;
15723 : case -1:
15724 : break;
15725 0 : case MS_IOERR:
15726 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15727 0 : _raise_ms_exception();
15728 0 : msResetErrorList();
15729 0 : return NULL;
15730 : }
15731 : default:
15732 0 : _raise_ms_exception();
15733 0 : msResetErrorList();
15734 0 : return NULL;
15735 : }
15736 :
15737 : }
15738 : }
15739 : resultobj = SWIG_Py_Void();
15740 1 : return resultobj;
15741 0 : fail:
15742 : return NULL;
15743 : }
15744 :
15745 :
15746 0 : SWIGINTERN PyObject *_wrap_labelObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15747 : PyObject *resultobj = 0;
15748 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15749 : char *arg2 = (char *) 0 ;
15750 0 : void *argp1 = 0 ;
15751 : int res1 = 0 ;
15752 : int res2 ;
15753 0 : char *buf2 = 0 ;
15754 0 : int alloc2 = 0 ;
15755 0 : PyObject * obj0 = 0 ;
15756 0 : PyObject * obj1 = 0 ;
15757 : int result;
15758 :
15759 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_updateFromString",&obj0,&obj1)) SWIG_fail;
15760 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15761 0 : if (!SWIG_IsOK(res1)) {
15762 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_updateFromString" "', argument " "1"" of type '" "struct labelObj *""'");
15763 : }
15764 0 : arg1 = (struct labelObj *)(argp1);
15765 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
15766 0 : if (!SWIG_IsOK(res2)) {
15767 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_updateFromString" "', argument " "2"" of type '" "char *""'");
15768 : }
15769 0 : arg2 = (char *)(buf2);
15770 : {
15771 : result = (int)labelObj_updateFromString(arg1,arg2); {
15772 0 : errorObj *ms_error = msGetErrorObj();
15773 :
15774 0 : switch(ms_error->code) {
15775 : case MS_NOERR:
15776 : break;
15777 0 : case MS_NOTFOUND:
15778 0 : msResetErrorList();
15779 0 : break;
15780 : case -1:
15781 : break;
15782 0 : case MS_IOERR:
15783 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15784 0 : _raise_ms_exception();
15785 0 : msResetErrorList();
15786 0 : return NULL;
15787 : }
15788 : default:
15789 0 : _raise_ms_exception();
15790 0 : msResetErrorList();
15791 0 : return NULL;
15792 : }
15793 :
15794 : }
15795 : }
15796 : resultobj = SWIG_From_int((int)(result));
15797 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15798 : return resultobj;
15799 0 : fail:
15800 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
15801 : return NULL;
15802 : }
15803 :
15804 :
15805 0 : SWIGINTERN PyObject *_wrap_labelObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15806 : PyObject *resultobj = 0;
15807 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15808 0 : void *argp1 = 0 ;
15809 : int res1 = 0 ;
15810 0 : PyObject * obj0 = 0 ;
15811 : char *result = 0 ;
15812 :
15813 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_convertToString",&obj0)) SWIG_fail;
15814 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15815 0 : if (!SWIG_IsOK(res1)) {
15816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_convertToString" "', argument " "1"" of type '" "struct labelObj *""'");
15817 : }
15818 0 : arg1 = (struct labelObj *)(argp1);
15819 : {
15820 : result = (char *)labelObj_convertToString(arg1); {
15821 0 : errorObj *ms_error = msGetErrorObj();
15822 :
15823 0 : switch(ms_error->code) {
15824 : case MS_NOERR:
15825 : break;
15826 0 : case MS_NOTFOUND:
15827 0 : msResetErrorList();
15828 0 : break;
15829 : case -1:
15830 : break;
15831 0 : case MS_IOERR:
15832 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15833 0 : _raise_ms_exception();
15834 0 : msResetErrorList();
15835 0 : return NULL;
15836 : }
15837 : default:
15838 0 : _raise_ms_exception();
15839 0 : msResetErrorList();
15840 0 : return NULL;
15841 : }
15842 :
15843 : }
15844 : }
15845 0 : resultobj = SWIG_FromCharPtr((const char *)result);
15846 0 : free((char*)result);
15847 0 : return resultobj;
15848 0 : fail:
15849 : return NULL;
15850 : }
15851 :
15852 :
15853 0 : SWIGINTERN PyObject *_wrap_labelObj_removeBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15854 : PyObject *resultobj = 0;
15855 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15856 : int arg2 ;
15857 0 : void *argp1 = 0 ;
15858 : int res1 = 0 ;
15859 : int val2 ;
15860 : int ecode2 = 0 ;
15861 0 : PyObject * obj0 = 0 ;
15862 0 : PyObject * obj1 = 0 ;
15863 : int result;
15864 :
15865 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_removeBinding",&obj0,&obj1)) SWIG_fail;
15866 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15867 0 : if (!SWIG_IsOK(res1)) {
15868 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_removeBinding" "', argument " "1"" of type '" "struct labelObj *""'");
15869 : }
15870 0 : arg1 = (struct labelObj *)(argp1);
15871 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15872 0 : if (!SWIG_IsOK(ecode2)) {
15873 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_removeBinding" "', argument " "2"" of type '" "int""'");
15874 : }
15875 : arg2 = (int)(val2);
15876 : {
15877 : result = (int)labelObj_removeBinding(arg1,arg2); {
15878 0 : errorObj *ms_error = msGetErrorObj();
15879 :
15880 0 : switch(ms_error->code) {
15881 : case MS_NOERR:
15882 : break;
15883 0 : case MS_NOTFOUND:
15884 0 : msResetErrorList();
15885 0 : break;
15886 : case -1:
15887 : break;
15888 0 : case MS_IOERR:
15889 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15890 0 : _raise_ms_exception();
15891 0 : msResetErrorList();
15892 0 : return NULL;
15893 : }
15894 : default:
15895 0 : _raise_ms_exception();
15896 0 : msResetErrorList();
15897 0 : return NULL;
15898 : }
15899 :
15900 : }
15901 : }
15902 : resultobj = SWIG_From_int((int)(result));
15903 0 : return resultobj;
15904 0 : fail:
15905 : return NULL;
15906 : }
15907 :
15908 :
15909 1 : SWIGINTERN PyObject *_wrap_labelObj_getBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15910 : PyObject *resultobj = 0;
15911 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15912 : int arg2 ;
15913 1 : void *argp1 = 0 ;
15914 : int res1 = 0 ;
15915 : int val2 ;
15916 : int ecode2 = 0 ;
15917 1 : PyObject * obj0 = 0 ;
15918 1 : PyObject * obj1 = 0 ;
15919 : char *result = 0 ;
15920 :
15921 1 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_getBinding",&obj0,&obj1)) SWIG_fail;
15922 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15923 1 : if (!SWIG_IsOK(res1)) {
15924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getBinding" "', argument " "1"" of type '" "struct labelObj *""'");
15925 : }
15926 1 : arg1 = (struct labelObj *)(argp1);
15927 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15928 1 : if (!SWIG_IsOK(ecode2)) {
15929 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_getBinding" "', argument " "2"" of type '" "int""'");
15930 : }
15931 : arg2 = (int)(val2);
15932 : {
15933 : result = (char *)labelObj_getBinding(arg1,arg2); {
15934 1 : errorObj *ms_error = msGetErrorObj();
15935 :
15936 1 : switch(ms_error->code) {
15937 : case MS_NOERR:
15938 : break;
15939 0 : case MS_NOTFOUND:
15940 0 : msResetErrorList();
15941 0 : break;
15942 : case -1:
15943 : break;
15944 0 : case MS_IOERR:
15945 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
15946 0 : _raise_ms_exception();
15947 0 : msResetErrorList();
15948 0 : return NULL;
15949 : }
15950 : default:
15951 0 : _raise_ms_exception();
15952 0 : msResetErrorList();
15953 0 : return NULL;
15954 : }
15955 :
15956 : }
15957 : }
15958 1 : resultobj = SWIG_FromCharPtr((const char *)result);
15959 1 : return resultobj;
15960 0 : fail:
15961 : return NULL;
15962 : }
15963 :
15964 :
15965 1 : SWIGINTERN PyObject *_wrap_labelObj_setBinding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15966 : PyObject *resultobj = 0;
15967 : struct labelObj *arg1 = (struct labelObj *) 0 ;
15968 : int arg2 ;
15969 : char *arg3 = (char *) 0 ;
15970 1 : void *argp1 = 0 ;
15971 : int res1 = 0 ;
15972 : int val2 ;
15973 : int ecode2 = 0 ;
15974 : int res3 ;
15975 1 : char *buf3 = 0 ;
15976 1 : int alloc3 = 0 ;
15977 1 : PyObject * obj0 = 0 ;
15978 1 : PyObject * obj1 = 0 ;
15979 1 : PyObject * obj2 = 0 ;
15980 : int result;
15981 :
15982 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:labelObj_setBinding",&obj0,&obj1,&obj2)) SWIG_fail;
15983 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
15984 1 : if (!SWIG_IsOK(res1)) {
15985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setBinding" "', argument " "1"" of type '" "struct labelObj *""'");
15986 : }
15987 1 : arg1 = (struct labelObj *)(argp1);
15988 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
15989 1 : if (!SWIG_IsOK(ecode2)) {
15990 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_setBinding" "', argument " "2"" of type '" "int""'");
15991 : }
15992 : arg2 = (int)(val2);
15993 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
15994 1 : if (!SWIG_IsOK(res3)) {
15995 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "labelObj_setBinding" "', argument " "3"" of type '" "char *""'");
15996 : }
15997 1 : arg3 = (char *)(buf3);
15998 : {
15999 1 : result = (int)labelObj_setBinding(arg1,arg2,arg3); {
16000 1 : errorObj *ms_error = msGetErrorObj();
16001 :
16002 1 : switch(ms_error->code) {
16003 : case MS_NOERR:
16004 : break;
16005 0 : case MS_NOTFOUND:
16006 0 : msResetErrorList();
16007 0 : break;
16008 : case -1:
16009 : break;
16010 0 : case MS_IOERR:
16011 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16012 0 : _raise_ms_exception();
16013 0 : msResetErrorList();
16014 0 : return NULL;
16015 : }
16016 : default:
16017 0 : _raise_ms_exception();
16018 0 : msResetErrorList();
16019 0 : return NULL;
16020 : }
16021 :
16022 : }
16023 : }
16024 : resultobj = SWIG_From_int((int)(result));
16025 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
16026 : return resultobj;
16027 0 : fail:
16028 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
16029 : return NULL;
16030 : }
16031 :
16032 :
16033 0 : SWIGINTERN PyObject *_wrap_labelObj_setExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16034 : PyObject *resultobj = 0;
16035 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16036 : char *arg2 = (char *) 0 ;
16037 0 : void *argp1 = 0 ;
16038 : int res1 = 0 ;
16039 : int res2 ;
16040 0 : char *buf2 = 0 ;
16041 0 : int alloc2 = 0 ;
16042 0 : PyObject * obj0 = 0 ;
16043 0 : PyObject * obj1 = 0 ;
16044 : int result;
16045 :
16046 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_setExpression",&obj0,&obj1)) SWIG_fail;
16047 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16048 0 : if (!SWIG_IsOK(res1)) {
16049 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setExpression" "', argument " "1"" of type '" "struct labelObj *""'");
16050 : }
16051 0 : arg1 = (struct labelObj *)(argp1);
16052 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16053 0 : if (!SWIG_IsOK(res2)) {
16054 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_setExpression" "', argument " "2"" of type '" "char *""'");
16055 : }
16056 0 : arg2 = (char *)(buf2);
16057 : {
16058 0 : result = (int)labelObj_setExpression(arg1,arg2); {
16059 0 : errorObj *ms_error = msGetErrorObj();
16060 :
16061 0 : switch(ms_error->code) {
16062 : case MS_NOERR:
16063 : break;
16064 0 : case MS_NOTFOUND:
16065 0 : msResetErrorList();
16066 0 : break;
16067 : case -1:
16068 : break;
16069 0 : case MS_IOERR:
16070 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16071 0 : _raise_ms_exception();
16072 0 : msResetErrorList();
16073 0 : return NULL;
16074 : }
16075 : default:
16076 0 : _raise_ms_exception();
16077 0 : msResetErrorList();
16078 0 : return NULL;
16079 : }
16080 :
16081 : }
16082 : }
16083 : resultobj = SWIG_From_int((int)(result));
16084 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16085 : return resultobj;
16086 0 : fail:
16087 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16088 : return NULL;
16089 : }
16090 :
16091 :
16092 0 : SWIGINTERN PyObject *_wrap_labelObj_getExpressionString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16093 : PyObject *resultobj = 0;
16094 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16095 0 : void *argp1 = 0 ;
16096 : int res1 = 0 ;
16097 0 : PyObject * obj0 = 0 ;
16098 : char *result = 0 ;
16099 :
16100 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_getExpressionString",&obj0)) SWIG_fail;
16101 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16102 0 : if (!SWIG_IsOK(res1)) {
16103 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getExpressionString" "', argument " "1"" of type '" "struct labelObj *""'");
16104 : }
16105 0 : arg1 = (struct labelObj *)(argp1);
16106 : {
16107 : result = (char *)labelObj_getExpressionString(arg1); {
16108 0 : errorObj *ms_error = msGetErrorObj();
16109 :
16110 0 : switch(ms_error->code) {
16111 : case MS_NOERR:
16112 : break;
16113 0 : case MS_NOTFOUND:
16114 0 : msResetErrorList();
16115 0 : break;
16116 : case -1:
16117 : break;
16118 0 : case MS_IOERR:
16119 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16120 0 : _raise_ms_exception();
16121 0 : msResetErrorList();
16122 0 : return NULL;
16123 : }
16124 : default:
16125 0 : _raise_ms_exception();
16126 0 : msResetErrorList();
16127 0 : return NULL;
16128 : }
16129 :
16130 : }
16131 : }
16132 0 : resultobj = SWIG_FromCharPtr((const char *)result);
16133 0 : free((char*)result);
16134 0 : return resultobj;
16135 0 : fail:
16136 : return NULL;
16137 : }
16138 :
16139 :
16140 0 : SWIGINTERN PyObject *_wrap_labelObj_setText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16141 : PyObject *resultobj = 0;
16142 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16143 : char *arg2 = (char *) 0 ;
16144 0 : void *argp1 = 0 ;
16145 : int res1 = 0 ;
16146 : int res2 ;
16147 0 : char *buf2 = 0 ;
16148 0 : int alloc2 = 0 ;
16149 0 : PyObject * obj0 = 0 ;
16150 0 : PyObject * obj1 = 0 ;
16151 : int result;
16152 :
16153 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_setText",&obj0,&obj1)) SWIG_fail;
16154 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16155 0 : if (!SWIG_IsOK(res1)) {
16156 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_setText" "', argument " "1"" of type '" "struct labelObj *""'");
16157 : }
16158 0 : arg1 = (struct labelObj *)(argp1);
16159 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16160 0 : if (!SWIG_IsOK(res2)) {
16161 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_setText" "', argument " "2"" of type '" "char *""'");
16162 : }
16163 0 : arg2 = (char *)(buf2);
16164 : {
16165 0 : result = (int)labelObj_setText(arg1,arg2); {
16166 0 : errorObj *ms_error = msGetErrorObj();
16167 :
16168 0 : switch(ms_error->code) {
16169 : case MS_NOERR:
16170 : break;
16171 0 : case MS_NOTFOUND:
16172 0 : msResetErrorList();
16173 0 : break;
16174 : case -1:
16175 : break;
16176 0 : case MS_IOERR:
16177 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16178 0 : _raise_ms_exception();
16179 0 : msResetErrorList();
16180 0 : return NULL;
16181 : }
16182 : default:
16183 0 : _raise_ms_exception();
16184 0 : msResetErrorList();
16185 0 : return NULL;
16186 : }
16187 :
16188 : }
16189 : }
16190 : resultobj = SWIG_From_int((int)(result));
16191 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16192 : return resultobj;
16193 0 : fail:
16194 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16195 : return NULL;
16196 : }
16197 :
16198 :
16199 0 : SWIGINTERN PyObject *_wrap_labelObj_getTextString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16200 : PyObject *resultobj = 0;
16201 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16202 0 : void *argp1 = 0 ;
16203 : int res1 = 0 ;
16204 0 : PyObject * obj0 = 0 ;
16205 : char *result = 0 ;
16206 :
16207 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelObj_getTextString",&obj0)) SWIG_fail;
16208 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16209 0 : if (!SWIG_IsOK(res1)) {
16210 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getTextString" "', argument " "1"" of type '" "struct labelObj *""'");
16211 : }
16212 0 : arg1 = (struct labelObj *)(argp1);
16213 : {
16214 : result = (char *)labelObj_getTextString(arg1); {
16215 0 : errorObj *ms_error = msGetErrorObj();
16216 :
16217 0 : switch(ms_error->code) {
16218 : case MS_NOERR:
16219 : break;
16220 0 : case MS_NOTFOUND:
16221 0 : msResetErrorList();
16222 0 : break;
16223 : case -1:
16224 : break;
16225 0 : case MS_IOERR:
16226 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16227 0 : _raise_ms_exception();
16228 0 : msResetErrorList();
16229 0 : return NULL;
16230 : }
16231 : default:
16232 0 : _raise_ms_exception();
16233 0 : msResetErrorList();
16234 0 : return NULL;
16235 : }
16236 :
16237 : }
16238 : }
16239 0 : resultobj = SWIG_FromCharPtr((const char *)result);
16240 0 : free((char*)result);
16241 0 : return resultobj;
16242 0 : fail:
16243 : return NULL;
16244 : }
16245 :
16246 :
16247 0 : SWIGINTERN PyObject *_wrap_labelObj_getStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16248 : PyObject *resultobj = 0;
16249 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16250 : int arg2 ;
16251 0 : void *argp1 = 0 ;
16252 : int res1 = 0 ;
16253 : int val2 ;
16254 : int ecode2 = 0 ;
16255 0 : PyObject * obj0 = 0 ;
16256 0 : PyObject * obj1 = 0 ;
16257 : styleObj *result = 0 ;
16258 :
16259 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_getStyle",&obj0,&obj1)) SWIG_fail;
16260 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16261 0 : if (!SWIG_IsOK(res1)) {
16262 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_getStyle" "', argument " "1"" of type '" "struct labelObj *""'");
16263 : }
16264 0 : arg1 = (struct labelObj *)(argp1);
16265 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16266 0 : if (!SWIG_IsOK(ecode2)) {
16267 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_getStyle" "', argument " "2"" of type '" "int""'");
16268 : }
16269 : arg2 = (int)(val2);
16270 : {
16271 0 : result = (styleObj *)labelObj_getStyle(arg1,arg2); {
16272 0 : errorObj *ms_error = msGetErrorObj();
16273 :
16274 0 : switch(ms_error->code) {
16275 : case MS_NOERR:
16276 : break;
16277 0 : case MS_NOTFOUND:
16278 0 : msResetErrorList();
16279 0 : break;
16280 : case -1:
16281 : break;
16282 0 : case MS_IOERR:
16283 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16284 0 : _raise_ms_exception();
16285 0 : msResetErrorList();
16286 0 : return NULL;
16287 : }
16288 : default:
16289 0 : _raise_ms_exception();
16290 0 : msResetErrorList();
16291 0 : return NULL;
16292 : }
16293 :
16294 : }
16295 : }
16296 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN | 0 );
16297 0 : return resultobj;
16298 0 : fail:
16299 : return NULL;
16300 : }
16301 :
16302 :
16303 0 : SWIGINTERN PyObject *_wrap_labelObj_insertStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16304 : PyObject *resultobj = 0;
16305 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16306 : styleObj *arg2 = (styleObj *) 0 ;
16307 : int arg3 = (int) -1 ;
16308 0 : void *argp1 = 0 ;
16309 : int res1 = 0 ;
16310 0 : void *argp2 = 0 ;
16311 : int res2 = 0 ;
16312 : int val3 ;
16313 : int ecode3 = 0 ;
16314 0 : PyObject * obj0 = 0 ;
16315 0 : PyObject * obj1 = 0 ;
16316 0 : PyObject * obj2 = 0 ;
16317 : int result;
16318 :
16319 0 : if (!PyArg_ParseTuple(args,(char *)"OO|O:labelObj_insertStyle",&obj0,&obj1,&obj2)) SWIG_fail;
16320 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16321 0 : if (!SWIG_IsOK(res1)) {
16322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_insertStyle" "', argument " "1"" of type '" "struct labelObj *""'");
16323 : }
16324 0 : arg1 = (struct labelObj *)(argp1);
16325 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_styleObj, 0 | 0 );
16326 0 : if (!SWIG_IsOK(res2)) {
16327 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "labelObj_insertStyle" "', argument " "2"" of type '" "styleObj *""'");
16328 : }
16329 0 : arg2 = (styleObj *)(argp2);
16330 0 : if (obj2) {
16331 : ecode3 = SWIG_AsVal_int(obj2, &val3);
16332 0 : if (!SWIG_IsOK(ecode3)) {
16333 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "labelObj_insertStyle" "', argument " "3"" of type '" "int""'");
16334 : }
16335 : arg3 = (int)(val3);
16336 : }
16337 : {
16338 : result = (int)labelObj_insertStyle(arg1,arg2,arg3); {
16339 0 : errorObj *ms_error = msGetErrorObj();
16340 :
16341 0 : switch(ms_error->code) {
16342 : case MS_NOERR:
16343 : break;
16344 0 : case MS_NOTFOUND:
16345 0 : msResetErrorList();
16346 0 : break;
16347 : case -1:
16348 : break;
16349 0 : case MS_IOERR:
16350 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16351 0 : _raise_ms_exception();
16352 0 : msResetErrorList();
16353 0 : return NULL;
16354 : }
16355 : default:
16356 0 : _raise_ms_exception();
16357 0 : msResetErrorList();
16358 0 : return NULL;
16359 : }
16360 :
16361 : }
16362 : }
16363 : resultobj = SWIG_From_int((int)(result));
16364 0 : return resultobj;
16365 0 : fail:
16366 : return NULL;
16367 : }
16368 :
16369 :
16370 0 : SWIGINTERN PyObject *_wrap_labelObj_removeStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16371 : PyObject *resultobj = 0;
16372 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16373 : int arg2 ;
16374 0 : void *argp1 = 0 ;
16375 : int res1 = 0 ;
16376 : int val2 ;
16377 : int ecode2 = 0 ;
16378 0 : PyObject * obj0 = 0 ;
16379 0 : PyObject * obj1 = 0 ;
16380 : styleObj *result = 0 ;
16381 :
16382 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_removeStyle",&obj0,&obj1)) SWIG_fail;
16383 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16384 0 : if (!SWIG_IsOK(res1)) {
16385 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_removeStyle" "', argument " "1"" of type '" "struct labelObj *""'");
16386 : }
16387 0 : arg1 = (struct labelObj *)(argp1);
16388 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16389 0 : if (!SWIG_IsOK(ecode2)) {
16390 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_removeStyle" "', argument " "2"" of type '" "int""'");
16391 : }
16392 : arg2 = (int)(val2);
16393 : {
16394 0 : result = (styleObj *)labelObj_removeStyle(arg1,arg2); {
16395 0 : errorObj *ms_error = msGetErrorObj();
16396 :
16397 0 : switch(ms_error->code) {
16398 : case MS_NOERR:
16399 : break;
16400 0 : case MS_NOTFOUND:
16401 0 : msResetErrorList();
16402 0 : break;
16403 : case -1:
16404 : break;
16405 0 : case MS_IOERR:
16406 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16407 0 : _raise_ms_exception();
16408 0 : msResetErrorList();
16409 0 : return NULL;
16410 : }
16411 : default:
16412 0 : _raise_ms_exception();
16413 0 : msResetErrorList();
16414 0 : return NULL;
16415 : }
16416 :
16417 : }
16418 : }
16419 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN | 0 );
16420 0 : return resultobj;
16421 0 : fail:
16422 : return NULL;
16423 : }
16424 :
16425 :
16426 0 : SWIGINTERN PyObject *_wrap_labelObj_moveStyleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16427 : PyObject *resultobj = 0;
16428 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16429 : int arg2 ;
16430 0 : void *argp1 = 0 ;
16431 : int res1 = 0 ;
16432 : int val2 ;
16433 : int ecode2 = 0 ;
16434 0 : PyObject * obj0 = 0 ;
16435 0 : PyObject * obj1 = 0 ;
16436 : int result;
16437 :
16438 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_moveStyleUp",&obj0,&obj1)) SWIG_fail;
16439 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16440 0 : if (!SWIG_IsOK(res1)) {
16441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_moveStyleUp" "', argument " "1"" of type '" "struct labelObj *""'");
16442 : }
16443 0 : arg1 = (struct labelObj *)(argp1);
16444 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16445 0 : if (!SWIG_IsOK(ecode2)) {
16446 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_moveStyleUp" "', argument " "2"" of type '" "int""'");
16447 : }
16448 : arg2 = (int)(val2);
16449 : {
16450 : result = (int)labelObj_moveStyleUp(arg1,arg2); {
16451 0 : errorObj *ms_error = msGetErrorObj();
16452 :
16453 0 : switch(ms_error->code) {
16454 : case MS_NOERR:
16455 : break;
16456 0 : case MS_NOTFOUND:
16457 0 : msResetErrorList();
16458 0 : break;
16459 : case -1:
16460 : break;
16461 0 : case MS_IOERR:
16462 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16463 0 : _raise_ms_exception();
16464 0 : msResetErrorList();
16465 0 : return NULL;
16466 : }
16467 : default:
16468 0 : _raise_ms_exception();
16469 0 : msResetErrorList();
16470 0 : return NULL;
16471 : }
16472 :
16473 : }
16474 : }
16475 : resultobj = SWIG_From_int((int)(result));
16476 0 : return resultobj;
16477 0 : fail:
16478 : return NULL;
16479 : }
16480 :
16481 :
16482 0 : SWIGINTERN PyObject *_wrap_labelObj_moveStyleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16483 : PyObject *resultobj = 0;
16484 : struct labelObj *arg1 = (struct labelObj *) 0 ;
16485 : int arg2 ;
16486 0 : void *argp1 = 0 ;
16487 : int res1 = 0 ;
16488 : int val2 ;
16489 : int ecode2 = 0 ;
16490 0 : PyObject * obj0 = 0 ;
16491 0 : PyObject * obj1 = 0 ;
16492 : int result;
16493 :
16494 0 : if (!PyArg_ParseTuple(args,(char *)"OO:labelObj_moveStyleDown",&obj0,&obj1)) SWIG_fail;
16495 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelObj, 0 | 0 );
16496 0 : if (!SWIG_IsOK(res1)) {
16497 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelObj_moveStyleDown" "', argument " "1"" of type '" "struct labelObj *""'");
16498 : }
16499 0 : arg1 = (struct labelObj *)(argp1);
16500 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16501 0 : if (!SWIG_IsOK(ecode2)) {
16502 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "labelObj_moveStyleDown" "', argument " "2"" of type '" "int""'");
16503 : }
16504 : arg2 = (int)(val2);
16505 : {
16506 : result = (int)labelObj_moveStyleDown(arg1,arg2); {
16507 0 : errorObj *ms_error = msGetErrorObj();
16508 :
16509 0 : switch(ms_error->code) {
16510 : case MS_NOERR:
16511 : break;
16512 0 : case MS_NOTFOUND:
16513 0 : msResetErrorList();
16514 0 : break;
16515 : case -1:
16516 : break;
16517 0 : case MS_IOERR:
16518 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
16519 0 : _raise_ms_exception();
16520 0 : msResetErrorList();
16521 0 : return NULL;
16522 : }
16523 : default:
16524 0 : _raise_ms_exception();
16525 0 : msResetErrorList();
16526 0 : return NULL;
16527 : }
16528 :
16529 : }
16530 : }
16531 : resultobj = SWIG_From_int((int)(result));
16532 0 : return resultobj;
16533 0 : fail:
16534 : return NULL;
16535 : }
16536 :
16537 :
16538 1 : SWIGINTERN PyObject *labelObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16539 : PyObject *obj;
16540 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
16541 1 : SWIG_TypeNewClientData(SWIGTYPE_p_labelObj, SWIG_NewClientData(obj));
16542 1 : return SWIG_Py_Void();
16543 : }
16544 :
16545 1 : SWIGINTERN PyObject *_wrap_classObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16546 : PyObject *resultobj = 0;
16547 : struct classObj *arg1 = (struct classObj *) 0 ;
16548 1 : void *argp1 = 0 ;
16549 : int res1 = 0 ;
16550 1 : PyObject * obj0 = 0 ;
16551 : hashTableObj *result = 0 ;
16552 :
16553 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_metadata_get",&obj0)) SWIG_fail;
16554 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16555 1 : if (!SWIG_IsOK(res1)) {
16556 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_metadata_get" "', argument " "1"" of type '" "struct classObj *""'");
16557 : }
16558 1 : arg1 = (struct classObj *)(argp1);
16559 1 : result = (hashTableObj *)& ((arg1)->metadata);
16560 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
16561 1 : return resultobj;
16562 0 : fail:
16563 : return NULL;
16564 : }
16565 :
16566 :
16567 0 : SWIGINTERN PyObject *_wrap_classObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16568 : PyObject *resultobj = 0;
16569 : struct classObj *arg1 = (struct classObj *) 0 ;
16570 0 : void *argp1 = 0 ;
16571 : int res1 = 0 ;
16572 0 : PyObject * obj0 = 0 ;
16573 : hashTableObj *result = 0 ;
16574 :
16575 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_validation_get",&obj0)) SWIG_fail;
16576 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16577 0 : if (!SWIG_IsOK(res1)) {
16578 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_validation_get" "', argument " "1"" of type '" "struct classObj *""'");
16579 : }
16580 0 : arg1 = (struct classObj *)(argp1);
16581 0 : result = (hashTableObj *)& ((arg1)->validation);
16582 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
16583 0 : return resultobj;
16584 0 : fail:
16585 : return NULL;
16586 : }
16587 :
16588 :
16589 1 : SWIGINTERN PyObject *_wrap_classObj_numstyles_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16590 : PyObject *resultobj = 0;
16591 : struct classObj *arg1 = (struct classObj *) 0 ;
16592 1 : void *argp1 = 0 ;
16593 : int res1 = 0 ;
16594 1 : PyObject * obj0 = 0 ;
16595 : int result;
16596 :
16597 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_numstyles_get",&obj0)) SWIG_fail;
16598 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16599 1 : if (!SWIG_IsOK(res1)) {
16600 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_numstyles_get" "', argument " "1"" of type '" "struct classObj *""'");
16601 : }
16602 1 : arg1 = (struct classObj *)(argp1);
16603 1 : result = (int) ((arg1)->numstyles);
16604 : resultobj = SWIG_From_int((int)(result));
16605 1 : return resultobj;
16606 0 : fail:
16607 : return NULL;
16608 : }
16609 :
16610 :
16611 0 : SWIGINTERN PyObject *_wrap_classObj_numlabels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16612 : PyObject *resultobj = 0;
16613 : struct classObj *arg1 = (struct classObj *) 0 ;
16614 0 : void *argp1 = 0 ;
16615 : int res1 = 0 ;
16616 0 : PyObject * obj0 = 0 ;
16617 : int result;
16618 :
16619 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_numlabels_get",&obj0)) SWIG_fail;
16620 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16621 0 : if (!SWIG_IsOK(res1)) {
16622 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_numlabels_get" "', argument " "1"" of type '" "struct classObj *""'");
16623 : }
16624 0 : arg1 = (struct classObj *)(argp1);
16625 0 : result = (int) ((arg1)->numlabels);
16626 : resultobj = SWIG_From_int((int)(result));
16627 0 : return resultobj;
16628 0 : fail:
16629 : return NULL;
16630 : }
16631 :
16632 :
16633 1 : SWIGINTERN PyObject *_wrap_classObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16634 : PyObject *resultobj = 0;
16635 : struct classObj *arg1 = (struct classObj *) 0 ;
16636 1 : void *argp1 = 0 ;
16637 : int res1 = 0 ;
16638 1 : PyObject * obj0 = 0 ;
16639 : int result;
16640 :
16641 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_refcount_get",&obj0)) SWIG_fail;
16642 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16643 1 : if (!SWIG_IsOK(res1)) {
16644 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_refcount_get" "', argument " "1"" of type '" "struct classObj *""'");
16645 : }
16646 1 : arg1 = (struct classObj *)(argp1);
16647 1 : result = (int) ((arg1)->refcount);
16648 : resultobj = SWIG_From_int((int)(result));
16649 1 : return resultobj;
16650 0 : fail:
16651 : return NULL;
16652 : }
16653 :
16654 :
16655 1 : SWIGINTERN PyObject *_wrap_classObj_layer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16656 : PyObject *resultobj = 0;
16657 : struct classObj *arg1 = (struct classObj *) 0 ;
16658 1 : void *argp1 = 0 ;
16659 : int res1 = 0 ;
16660 1 : PyObject * obj0 = 0 ;
16661 : struct layerObj *result = 0 ;
16662 :
16663 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_layer_get",&obj0)) SWIG_fail;
16664 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16665 1 : if (!SWIG_IsOK(res1)) {
16666 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_layer_get" "', argument " "1"" of type '" "struct classObj *""'");
16667 : }
16668 1 : arg1 = (struct classObj *)(argp1);
16669 1 : result = (struct layerObj *) ((arg1)->layer);
16670 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, 0 | 0 );
16671 1 : return resultobj;
16672 0 : fail:
16673 : return NULL;
16674 : }
16675 :
16676 :
16677 0 : SWIGINTERN PyObject *_wrap_classObj_leader_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16678 : PyObject *resultobj = 0;
16679 : struct classObj *arg1 = (struct classObj *) 0 ;
16680 0 : void *argp1 = 0 ;
16681 : int res1 = 0 ;
16682 0 : PyObject * obj0 = 0 ;
16683 : labelLeaderObj *result = 0 ;
16684 :
16685 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_leader_get",&obj0)) SWIG_fail;
16686 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16687 0 : if (!SWIG_IsOK(res1)) {
16688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_leader_get" "', argument " "1"" of type '" "struct classObj *""'");
16689 : }
16690 0 : arg1 = (struct classObj *)(argp1);
16691 0 : result = (labelLeaderObj *) ((arg1)->leader);
16692 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelLeaderObj, 0 | 0 );
16693 0 : return resultobj;
16694 0 : fail:
16695 : return NULL;
16696 : }
16697 :
16698 :
16699 1 : SWIGINTERN PyObject *_wrap_classObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16700 : PyObject *resultobj = 0;
16701 : struct classObj *arg1 = (struct classObj *) 0 ;
16702 : int arg2 ;
16703 1 : void *argp1 = 0 ;
16704 : int res1 = 0 ;
16705 : int val2 ;
16706 : int ecode2 = 0 ;
16707 1 : PyObject * obj0 = 0 ;
16708 1 : PyObject * obj1 = 0 ;
16709 :
16710 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_status_set",&obj0,&obj1)) SWIG_fail;
16711 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16712 1 : if (!SWIG_IsOK(res1)) {
16713 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_status_set" "', argument " "1"" of type '" "struct classObj *""'");
16714 : }
16715 1 : arg1 = (struct classObj *)(argp1);
16716 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16717 1 : if (!SWIG_IsOK(ecode2)) {
16718 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_status_set" "', argument " "2"" of type '" "int""'");
16719 : }
16720 : arg2 = (int)(val2);
16721 1 : if (arg1) (arg1)->status = arg2;
16722 : resultobj = SWIG_Py_Void();
16723 1 : return resultobj;
16724 0 : fail:
16725 : return NULL;
16726 : }
16727 :
16728 :
16729 1 : SWIGINTERN PyObject *_wrap_classObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16730 : PyObject *resultobj = 0;
16731 : struct classObj *arg1 = (struct classObj *) 0 ;
16732 1 : void *argp1 = 0 ;
16733 : int res1 = 0 ;
16734 1 : PyObject * obj0 = 0 ;
16735 : int result;
16736 :
16737 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_status_get",&obj0)) SWIG_fail;
16738 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16739 1 : if (!SWIG_IsOK(res1)) {
16740 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_status_get" "', argument " "1"" of type '" "struct classObj *""'");
16741 : }
16742 1 : arg1 = (struct classObj *)(argp1);
16743 1 : result = (int) ((arg1)->status);
16744 : resultobj = SWIG_From_int((int)(result));
16745 1 : return resultobj;
16746 0 : fail:
16747 : return NULL;
16748 : }
16749 :
16750 :
16751 0 : SWIGINTERN PyObject *_wrap_classObj_isfallback_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16752 : PyObject *resultobj = 0;
16753 : struct classObj *arg1 = (struct classObj *) 0 ;
16754 : int arg2 ;
16755 0 : void *argp1 = 0 ;
16756 : int res1 = 0 ;
16757 : int val2 ;
16758 : int ecode2 = 0 ;
16759 0 : PyObject * obj0 = 0 ;
16760 0 : PyObject * obj1 = 0 ;
16761 :
16762 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_isfallback_set",&obj0,&obj1)) SWIG_fail;
16763 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16764 0 : if (!SWIG_IsOK(res1)) {
16765 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_isfallback_set" "', argument " "1"" of type '" "struct classObj *""'");
16766 : }
16767 0 : arg1 = (struct classObj *)(argp1);
16768 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
16769 0 : if (!SWIG_IsOK(ecode2)) {
16770 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_isfallback_set" "', argument " "2"" of type '" "int""'");
16771 : }
16772 : arg2 = (int)(val2);
16773 0 : if (arg1) (arg1)->isfallback = arg2;
16774 : resultobj = SWIG_Py_Void();
16775 0 : return resultobj;
16776 0 : fail:
16777 : return NULL;
16778 : }
16779 :
16780 :
16781 0 : SWIGINTERN PyObject *_wrap_classObj_isfallback_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16782 : PyObject *resultobj = 0;
16783 : struct classObj *arg1 = (struct classObj *) 0 ;
16784 0 : void *argp1 = 0 ;
16785 : int res1 = 0 ;
16786 0 : PyObject * obj0 = 0 ;
16787 : int result;
16788 :
16789 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_isfallback_get",&obj0)) SWIG_fail;
16790 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16791 0 : if (!SWIG_IsOK(res1)) {
16792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_isfallback_get" "', argument " "1"" of type '" "struct classObj *""'");
16793 : }
16794 0 : arg1 = (struct classObj *)(argp1);
16795 0 : result = (int) ((arg1)->isfallback);
16796 : resultobj = SWIG_From_int((int)(result));
16797 0 : return resultobj;
16798 0 : fail:
16799 : return NULL;
16800 : }
16801 :
16802 :
16803 1 : SWIGINTERN PyObject *_wrap_classObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16804 : PyObject *resultobj = 0;
16805 : struct classObj *arg1 = (struct classObj *) 0 ;
16806 : char *arg2 = (char *) 0 ;
16807 1 : void *argp1 = 0 ;
16808 : int res1 = 0 ;
16809 : int res2 ;
16810 1 : char *buf2 = 0 ;
16811 1 : int alloc2 = 0 ;
16812 1 : PyObject * obj0 = 0 ;
16813 1 : PyObject * obj1 = 0 ;
16814 :
16815 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_name_set",&obj0,&obj1)) SWIG_fail;
16816 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16817 1 : if (!SWIG_IsOK(res1)) {
16818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_name_set" "', argument " "1"" of type '" "struct classObj *""'");
16819 : }
16820 1 : arg1 = (struct classObj *)(argp1);
16821 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16822 1 : if (!SWIG_IsOK(res2)) {
16823 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_name_set" "', argument " "2"" of type '" "char *""'");
16824 : }
16825 1 : arg2 = (char *)(buf2);
16826 : {
16827 1 : if (arg1->name) free((char*)arg1->name);
16828 1 : if (arg2) {
16829 1 : arg1->name = (char *) malloc(strlen(arg2)+1);
16830 : strcpy((char*)arg1->name,arg2);
16831 : } else {
16832 0 : arg1->name = 0;
16833 : }
16834 : }
16835 : resultobj = SWIG_Py_Void();
16836 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16837 : return resultobj;
16838 0 : fail:
16839 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16840 : return NULL;
16841 : }
16842 :
16843 :
16844 1 : SWIGINTERN PyObject *_wrap_classObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16845 : PyObject *resultobj = 0;
16846 : struct classObj *arg1 = (struct classObj *) 0 ;
16847 1 : void *argp1 = 0 ;
16848 : int res1 = 0 ;
16849 1 : PyObject * obj0 = 0 ;
16850 : char *result = 0 ;
16851 :
16852 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_name_get",&obj0)) SWIG_fail;
16853 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16854 1 : if (!SWIG_IsOK(res1)) {
16855 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_name_get" "', argument " "1"" of type '" "struct classObj *""'");
16856 : }
16857 1 : arg1 = (struct classObj *)(argp1);
16858 1 : result = (char *) ((arg1)->name);
16859 1 : resultobj = SWIG_FromCharPtr((const char *)result);
16860 1 : return resultobj;
16861 0 : fail:
16862 : return NULL;
16863 : }
16864 :
16865 :
16866 1 : SWIGINTERN PyObject *_wrap_classObj_title_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16867 : PyObject *resultobj = 0;
16868 : struct classObj *arg1 = (struct classObj *) 0 ;
16869 : char *arg2 = (char *) 0 ;
16870 1 : void *argp1 = 0 ;
16871 : int res1 = 0 ;
16872 : int res2 ;
16873 1 : char *buf2 = 0 ;
16874 1 : int alloc2 = 0 ;
16875 1 : PyObject * obj0 = 0 ;
16876 1 : PyObject * obj1 = 0 ;
16877 :
16878 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_title_set",&obj0,&obj1)) SWIG_fail;
16879 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16880 1 : if (!SWIG_IsOK(res1)) {
16881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_title_set" "', argument " "1"" of type '" "struct classObj *""'");
16882 : }
16883 1 : arg1 = (struct classObj *)(argp1);
16884 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
16885 1 : if (!SWIG_IsOK(res2)) {
16886 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_title_set" "', argument " "2"" of type '" "char *""'");
16887 : }
16888 1 : arg2 = (char *)(buf2);
16889 : {
16890 1 : if (arg1->title) free((char*)arg1->title);
16891 1 : if (arg2) {
16892 1 : arg1->title = (char *) malloc(strlen(arg2)+1);
16893 : strcpy((char*)arg1->title,arg2);
16894 : } else {
16895 0 : arg1->title = 0;
16896 : }
16897 : }
16898 : resultobj = SWIG_Py_Void();
16899 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16900 : return resultobj;
16901 0 : fail:
16902 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
16903 : return NULL;
16904 : }
16905 :
16906 :
16907 1 : SWIGINTERN PyObject *_wrap_classObj_title_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16908 : PyObject *resultobj = 0;
16909 : struct classObj *arg1 = (struct classObj *) 0 ;
16910 1 : void *argp1 = 0 ;
16911 : int res1 = 0 ;
16912 1 : PyObject * obj0 = 0 ;
16913 : char *result = 0 ;
16914 :
16915 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_title_get",&obj0)) SWIG_fail;
16916 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16917 1 : if (!SWIG_IsOK(res1)) {
16918 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_title_get" "', argument " "1"" of type '" "struct classObj *""'");
16919 : }
16920 1 : arg1 = (struct classObj *)(argp1);
16921 1 : result = (char *) ((arg1)->title);
16922 1 : resultobj = SWIG_FromCharPtr((const char *)result);
16923 1 : return resultobj;
16924 0 : fail:
16925 : return NULL;
16926 : }
16927 :
16928 :
16929 1 : SWIGINTERN PyObject *_wrap_classObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16930 : PyObject *resultobj = 0;
16931 : struct classObj *arg1 = (struct classObj *) 0 ;
16932 : double arg2 ;
16933 1 : void *argp1 = 0 ;
16934 : int res1 = 0 ;
16935 : double val2 ;
16936 : int ecode2 = 0 ;
16937 1 : PyObject * obj0 = 0 ;
16938 1 : PyObject * obj1 = 0 ;
16939 :
16940 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
16941 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16942 1 : if (!SWIG_IsOK(res1)) {
16943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minscaledenom_set" "', argument " "1"" of type '" "struct classObj *""'");
16944 : }
16945 1 : arg1 = (struct classObj *)(argp1);
16946 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
16947 1 : if (!SWIG_IsOK(ecode2)) {
16948 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
16949 : }
16950 1 : arg2 = (double)(val2);
16951 1 : if (arg1) (arg1)->minscaledenom = arg2;
16952 : resultobj = SWIG_Py_Void();
16953 1 : return resultobj;
16954 0 : fail:
16955 : return NULL;
16956 : }
16957 :
16958 :
16959 1 : SWIGINTERN PyObject *_wrap_classObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16960 : PyObject *resultobj = 0;
16961 : struct classObj *arg1 = (struct classObj *) 0 ;
16962 1 : void *argp1 = 0 ;
16963 : int res1 = 0 ;
16964 1 : PyObject * obj0 = 0 ;
16965 : double result;
16966 :
16967 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_minscaledenom_get",&obj0)) SWIG_fail;
16968 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16969 1 : if (!SWIG_IsOK(res1)) {
16970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minscaledenom_get" "', argument " "1"" of type '" "struct classObj *""'");
16971 : }
16972 1 : arg1 = (struct classObj *)(argp1);
16973 1 : result = (double) ((arg1)->minscaledenom);
16974 1 : resultobj = SWIG_From_double((double)(result));
16975 1 : return resultobj;
16976 0 : fail:
16977 : return NULL;
16978 : }
16979 :
16980 :
16981 1 : SWIGINTERN PyObject *_wrap_classObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16982 : PyObject *resultobj = 0;
16983 : struct classObj *arg1 = (struct classObj *) 0 ;
16984 : double arg2 ;
16985 1 : void *argp1 = 0 ;
16986 : int res1 = 0 ;
16987 : double val2 ;
16988 : int ecode2 = 0 ;
16989 1 : PyObject * obj0 = 0 ;
16990 1 : PyObject * obj1 = 0 ;
16991 :
16992 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
16993 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
16994 1 : if (!SWIG_IsOK(res1)) {
16995 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_maxscaledenom_set" "', argument " "1"" of type '" "struct classObj *""'");
16996 : }
16997 1 : arg1 = (struct classObj *)(argp1);
16998 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
16999 1 : if (!SWIG_IsOK(ecode2)) {
17000 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
17001 : }
17002 1 : arg2 = (double)(val2);
17003 1 : if (arg1) (arg1)->maxscaledenom = arg2;
17004 : resultobj = SWIG_Py_Void();
17005 1 : return resultobj;
17006 0 : fail:
17007 : return NULL;
17008 : }
17009 :
17010 :
17011 1 : SWIGINTERN PyObject *_wrap_classObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17012 : PyObject *resultobj = 0;
17013 : struct classObj *arg1 = (struct classObj *) 0 ;
17014 1 : void *argp1 = 0 ;
17015 : int res1 = 0 ;
17016 1 : PyObject * obj0 = 0 ;
17017 : double result;
17018 :
17019 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_maxscaledenom_get",&obj0)) SWIG_fail;
17020 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17021 1 : if (!SWIG_IsOK(res1)) {
17022 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_maxscaledenom_get" "', argument " "1"" of type '" "struct classObj *""'");
17023 : }
17024 1 : arg1 = (struct classObj *)(argp1);
17025 1 : result = (double) ((arg1)->maxscaledenom);
17026 1 : resultobj = SWIG_From_double((double)(result));
17027 1 : return resultobj;
17028 0 : fail:
17029 : return NULL;
17030 : }
17031 :
17032 :
17033 1 : SWIGINTERN PyObject *_wrap_classObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17034 : PyObject *resultobj = 0;
17035 : struct classObj *arg1 = (struct classObj *) 0 ;
17036 : int arg2 ;
17037 1 : void *argp1 = 0 ;
17038 : int res1 = 0 ;
17039 : int val2 ;
17040 : int ecode2 = 0 ;
17041 1 : PyObject * obj0 = 0 ;
17042 1 : PyObject * obj1 = 0 ;
17043 :
17044 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
17045 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17046 1 : if (!SWIG_IsOK(res1)) {
17047 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minfeaturesize_set" "', argument " "1"" of type '" "struct classObj *""'");
17048 : }
17049 1 : arg1 = (struct classObj *)(argp1);
17050 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17051 1 : if (!SWIG_IsOK(ecode2)) {
17052 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
17053 : }
17054 : arg2 = (int)(val2);
17055 1 : if (arg1) (arg1)->minfeaturesize = arg2;
17056 : resultobj = SWIG_Py_Void();
17057 1 : return resultobj;
17058 0 : fail:
17059 : return NULL;
17060 : }
17061 :
17062 :
17063 1 : SWIGINTERN PyObject *_wrap_classObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17064 : PyObject *resultobj = 0;
17065 : struct classObj *arg1 = (struct classObj *) 0 ;
17066 1 : void *argp1 = 0 ;
17067 : int res1 = 0 ;
17068 1 : PyObject * obj0 = 0 ;
17069 : int result;
17070 :
17071 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_minfeaturesize_get",&obj0)) SWIG_fail;
17072 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17073 1 : if (!SWIG_IsOK(res1)) {
17074 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_minfeaturesize_get" "', argument " "1"" of type '" "struct classObj *""'");
17075 : }
17076 1 : arg1 = (struct classObj *)(argp1);
17077 1 : result = (int) ((arg1)->minfeaturesize);
17078 : resultobj = SWIG_From_int((int)(result));
17079 1 : return resultobj;
17080 0 : fail:
17081 : return NULL;
17082 : }
17083 :
17084 :
17085 1 : SWIGINTERN PyObject *_wrap_classObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17086 : PyObject *resultobj = 0;
17087 : struct classObj *arg1 = (struct classObj *) 0 ;
17088 : int arg2 ;
17089 1 : void *argp1 = 0 ;
17090 : int res1 = 0 ;
17091 : int val2 ;
17092 : int ecode2 = 0 ;
17093 1 : PyObject * obj0 = 0 ;
17094 1 : PyObject * obj1 = 0 ;
17095 :
17096 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_debug_set",&obj0,&obj1)) SWIG_fail;
17097 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17098 1 : if (!SWIG_IsOK(res1)) {
17099 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_debug_set" "', argument " "1"" of type '" "struct classObj *""'");
17100 : }
17101 1 : arg1 = (struct classObj *)(argp1);
17102 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17103 1 : if (!SWIG_IsOK(ecode2)) {
17104 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_debug_set" "', argument " "2"" of type '" "int""'");
17105 : }
17106 : arg2 = (int)(val2);
17107 1 : if (arg1) (arg1)->debug = arg2;
17108 : resultobj = SWIG_Py_Void();
17109 1 : return resultobj;
17110 0 : fail:
17111 : return NULL;
17112 : }
17113 :
17114 :
17115 1 : SWIGINTERN PyObject *_wrap_classObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17116 : PyObject *resultobj = 0;
17117 : struct classObj *arg1 = (struct classObj *) 0 ;
17118 1 : void *argp1 = 0 ;
17119 : int res1 = 0 ;
17120 1 : PyObject * obj0 = 0 ;
17121 : int result;
17122 :
17123 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_debug_get",&obj0)) SWIG_fail;
17124 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17125 1 : if (!SWIG_IsOK(res1)) {
17126 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_debug_get" "', argument " "1"" of type '" "struct classObj *""'");
17127 : }
17128 1 : arg1 = (struct classObj *)(argp1);
17129 1 : result = (int) ((arg1)->debug);
17130 : resultobj = SWIG_From_int((int)(result));
17131 1 : return resultobj;
17132 0 : fail:
17133 : return NULL;
17134 : }
17135 :
17136 :
17137 1 : SWIGINTERN PyObject *_wrap_classObj_keyimage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17138 : PyObject *resultobj = 0;
17139 : struct classObj *arg1 = (struct classObj *) 0 ;
17140 : char *arg2 = (char *) 0 ;
17141 1 : void *argp1 = 0 ;
17142 : int res1 = 0 ;
17143 : int res2 ;
17144 1 : char *buf2 = 0 ;
17145 1 : int alloc2 = 0 ;
17146 1 : PyObject * obj0 = 0 ;
17147 1 : PyObject * obj1 = 0 ;
17148 :
17149 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_keyimage_set",&obj0,&obj1)) SWIG_fail;
17150 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17151 1 : if (!SWIG_IsOK(res1)) {
17152 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_keyimage_set" "', argument " "1"" of type '" "struct classObj *""'");
17153 : }
17154 1 : arg1 = (struct classObj *)(argp1);
17155 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17156 1 : if (!SWIG_IsOK(res2)) {
17157 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_keyimage_set" "', argument " "2"" of type '" "char *""'");
17158 : }
17159 1 : arg2 = (char *)(buf2);
17160 : {
17161 1 : if (arg1->keyimage) free((char*)arg1->keyimage);
17162 1 : if (arg2) {
17163 1 : arg1->keyimage = (char *) malloc(strlen(arg2)+1);
17164 : strcpy((char*)arg1->keyimage,arg2);
17165 : } else {
17166 0 : arg1->keyimage = 0;
17167 : }
17168 : }
17169 : resultobj = SWIG_Py_Void();
17170 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17171 : return resultobj;
17172 0 : fail:
17173 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17174 : return NULL;
17175 : }
17176 :
17177 :
17178 1 : SWIGINTERN PyObject *_wrap_classObj_keyimage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17179 : PyObject *resultobj = 0;
17180 : struct classObj *arg1 = (struct classObj *) 0 ;
17181 1 : void *argp1 = 0 ;
17182 : int res1 = 0 ;
17183 1 : PyObject * obj0 = 0 ;
17184 : char *result = 0 ;
17185 :
17186 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_keyimage_get",&obj0)) SWIG_fail;
17187 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17188 1 : if (!SWIG_IsOK(res1)) {
17189 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_keyimage_get" "', argument " "1"" of type '" "struct classObj *""'");
17190 : }
17191 1 : arg1 = (struct classObj *)(argp1);
17192 1 : result = (char *) ((arg1)->keyimage);
17193 1 : resultobj = SWIG_FromCharPtr((const char *)result);
17194 1 : return resultobj;
17195 0 : fail:
17196 : return NULL;
17197 : }
17198 :
17199 :
17200 1 : SWIGINTERN PyObject *_wrap_classObj_group_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17201 : PyObject *resultobj = 0;
17202 : struct classObj *arg1 = (struct classObj *) 0 ;
17203 : char *arg2 = (char *) 0 ;
17204 1 : void *argp1 = 0 ;
17205 : int res1 = 0 ;
17206 : int res2 ;
17207 1 : char *buf2 = 0 ;
17208 1 : int alloc2 = 0 ;
17209 1 : PyObject * obj0 = 0 ;
17210 1 : PyObject * obj1 = 0 ;
17211 :
17212 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_group_set",&obj0,&obj1)) SWIG_fail;
17213 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17214 1 : if (!SWIG_IsOK(res1)) {
17215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_group_set" "', argument " "1"" of type '" "struct classObj *""'");
17216 : }
17217 1 : arg1 = (struct classObj *)(argp1);
17218 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17219 1 : if (!SWIG_IsOK(res2)) {
17220 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_group_set" "', argument " "2"" of type '" "char *""'");
17221 : }
17222 1 : arg2 = (char *)(buf2);
17223 : {
17224 1 : if (arg1->group) free((char*)arg1->group);
17225 1 : if (arg2) {
17226 1 : arg1->group = (char *) malloc(strlen(arg2)+1);
17227 : strcpy((char*)arg1->group,arg2);
17228 : } else {
17229 0 : arg1->group = 0;
17230 : }
17231 : }
17232 : resultobj = SWIG_Py_Void();
17233 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17234 : return resultobj;
17235 0 : fail:
17236 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17237 : return NULL;
17238 : }
17239 :
17240 :
17241 1 : SWIGINTERN PyObject *_wrap_classObj_group_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17242 : PyObject *resultobj = 0;
17243 : struct classObj *arg1 = (struct classObj *) 0 ;
17244 1 : void *argp1 = 0 ;
17245 : int res1 = 0 ;
17246 1 : PyObject * obj0 = 0 ;
17247 : char *result = 0 ;
17248 :
17249 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_group_get",&obj0)) SWIG_fail;
17250 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17251 1 : if (!SWIG_IsOK(res1)) {
17252 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_group_get" "', argument " "1"" of type '" "struct classObj *""'");
17253 : }
17254 1 : arg1 = (struct classObj *)(argp1);
17255 1 : result = (char *) ((arg1)->group);
17256 1 : resultobj = SWIG_FromCharPtr((const char *)result);
17257 1 : return resultobj;
17258 0 : fail:
17259 : return NULL;
17260 : }
17261 :
17262 :
17263 0 : SWIGINTERN PyObject *_wrap_classObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17264 : PyObject *resultobj = 0;
17265 : struct classObj *arg1 = (struct classObj *) 0 ;
17266 : int arg2 ;
17267 0 : void *argp1 = 0 ;
17268 : int res1 = 0 ;
17269 : int val2 ;
17270 : int ecode2 = 0 ;
17271 0 : PyObject * obj0 = 0 ;
17272 0 : PyObject * obj1 = 0 ;
17273 :
17274 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
17275 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17276 0 : if (!SWIG_IsOK(res1)) {
17277 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_sizeunits_set" "', argument " "1"" of type '" "struct classObj *""'");
17278 : }
17279 0 : arg1 = (struct classObj *)(argp1);
17280 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17281 0 : if (!SWIG_IsOK(ecode2)) {
17282 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
17283 : }
17284 : arg2 = (int)(val2);
17285 0 : if (arg1) (arg1)->sizeunits = arg2;
17286 : resultobj = SWIG_Py_Void();
17287 0 : return resultobj;
17288 0 : fail:
17289 : return NULL;
17290 : }
17291 :
17292 :
17293 0 : SWIGINTERN PyObject *_wrap_classObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 : PyObject *resultobj = 0;
17295 : struct classObj *arg1 = (struct classObj *) 0 ;
17296 0 : void *argp1 = 0 ;
17297 : int res1 = 0 ;
17298 0 : PyObject * obj0 = 0 ;
17299 : int result;
17300 :
17301 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_sizeunits_get",&obj0)) SWIG_fail;
17302 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17303 0 : if (!SWIG_IsOK(res1)) {
17304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_sizeunits_get" "', argument " "1"" of type '" "struct classObj *""'");
17305 : }
17306 0 : arg1 = (struct classObj *)(argp1);
17307 0 : result = (int) ((arg1)->sizeunits);
17308 : resultobj = SWIG_From_int((int)(result));
17309 0 : return resultobj;
17310 0 : fail:
17311 : return NULL;
17312 : }
17313 :
17314 :
17315 1 : SWIGINTERN PyObject *_wrap_classObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17316 : PyObject *resultobj = 0;
17317 : struct classObj *arg1 = (struct classObj *) 0 ;
17318 : char *arg2 = (char *) 0 ;
17319 1 : void *argp1 = 0 ;
17320 : int res1 = 0 ;
17321 : int res2 ;
17322 1 : char *buf2 = 0 ;
17323 1 : int alloc2 = 0 ;
17324 1 : PyObject * obj0 = 0 ;
17325 1 : PyObject * obj1 = 0 ;
17326 :
17327 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_template_set",&obj0,&obj1)) SWIG_fail;
17328 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17329 1 : if (!SWIG_IsOK(res1)) {
17330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_template_set" "', argument " "1"" of type '" "struct classObj *""'");
17331 : }
17332 1 : arg1 = (struct classObj *)(argp1);
17333 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17334 1 : if (!SWIG_IsOK(res2)) {
17335 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_template_set" "', argument " "2"" of type '" "char *""'");
17336 : }
17337 1 : arg2 = (char *)(buf2);
17338 : {
17339 1 : if (arg1->template) free((char*)arg1->template);
17340 1 : if (arg2) {
17341 1 : arg1->template = (char *) malloc(strlen(arg2)+1);
17342 : strcpy((char*)arg1->template,arg2);
17343 : } else {
17344 0 : arg1->template = 0;
17345 : }
17346 : }
17347 : resultobj = SWIG_Py_Void();
17348 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17349 : return resultobj;
17350 0 : fail:
17351 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17352 : return NULL;
17353 : }
17354 :
17355 :
17356 1 : SWIGINTERN PyObject *_wrap_classObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17357 : PyObject *resultobj = 0;
17358 : struct classObj *arg1 = (struct classObj *) 0 ;
17359 1 : void *argp1 = 0 ;
17360 : int res1 = 0 ;
17361 1 : PyObject * obj0 = 0 ;
17362 : char *result = 0 ;
17363 :
17364 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_template_get",&obj0)) SWIG_fail;
17365 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17366 1 : if (!SWIG_IsOK(res1)) {
17367 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_template_get" "', argument " "1"" of type '" "struct classObj *""'");
17368 : }
17369 1 : arg1 = (struct classObj *)(argp1);
17370 1 : result = (char *) ((arg1)->template);
17371 1 : resultobj = SWIG_FromCharPtr((const char *)result);
17372 1 : return resultobj;
17373 0 : fail:
17374 : return NULL;
17375 : }
17376 :
17377 :
17378 1 : SWIGINTERN PyObject *_wrap_new_classObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17379 : PyObject *resultobj = 0;
17380 : layerObj *arg1 = (layerObj *) NULL ;
17381 1 : void *argp1 = 0 ;
17382 : int res1 = 0 ;
17383 1 : PyObject * obj0 = 0 ;
17384 : struct classObj *result = 0 ;
17385 :
17386 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_classObj",&obj0)) SWIG_fail;
17387 1 : if (obj0) {
17388 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
17389 1 : if (!SWIG_IsOK(res1)) {
17390 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_classObj" "', argument " "1"" of type '" "layerObj *""'");
17391 : }
17392 1 : arg1 = (layerObj *)(argp1);
17393 : }
17394 : {
17395 1 : result = (struct classObj *)new_classObj(arg1); {
17396 1 : errorObj *ms_error = msGetErrorObj();
17397 :
17398 1 : switch(ms_error->code) {
17399 : case MS_NOERR:
17400 : break;
17401 0 : case MS_NOTFOUND:
17402 0 : msResetErrorList();
17403 0 : break;
17404 : case -1:
17405 : break;
17406 0 : case MS_IOERR:
17407 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17408 0 : _raise_ms_exception();
17409 0 : msResetErrorList();
17410 0 : return NULL;
17411 : }
17412 : default:
17413 0 : _raise_ms_exception();
17414 0 : msResetErrorList();
17415 0 : return NULL;
17416 : }
17417 :
17418 : }
17419 : }
17420 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_NEW | 0 );
17421 1 : return resultobj;
17422 0 : fail:
17423 : return NULL;
17424 : }
17425 :
17426 :
17427 1 : SWIGINTERN PyObject *_wrap_delete_classObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 : PyObject *resultobj = 0;
17429 : struct classObj *arg1 = (struct classObj *) 0 ;
17430 1 : void *argp1 = 0 ;
17431 : int res1 = 0 ;
17432 1 : PyObject * obj0 = 0 ;
17433 :
17434 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_classObj",&obj0)) SWIG_fail;
17435 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, SWIG_POINTER_DISOWN | 0 );
17436 1 : if (!SWIG_IsOK(res1)) {
17437 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_classObj" "', argument " "1"" of type '" "struct classObj *""'");
17438 : }
17439 1 : arg1 = (struct classObj *)(argp1);
17440 : {
17441 1 : delete_classObj(arg1); {
17442 1 : errorObj *ms_error = msGetErrorObj();
17443 :
17444 1 : switch(ms_error->code) {
17445 : case MS_NOERR:
17446 : break;
17447 0 : case MS_NOTFOUND:
17448 0 : msResetErrorList();
17449 0 : break;
17450 : case -1:
17451 : break;
17452 0 : case MS_IOERR:
17453 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17454 0 : _raise_ms_exception();
17455 0 : msResetErrorList();
17456 0 : return NULL;
17457 : }
17458 : default:
17459 0 : _raise_ms_exception();
17460 0 : msResetErrorList();
17461 0 : return NULL;
17462 : }
17463 :
17464 : }
17465 : }
17466 : resultobj = SWIG_Py_Void();
17467 1 : return resultobj;
17468 0 : fail:
17469 : return NULL;
17470 : }
17471 :
17472 :
17473 0 : SWIGINTERN PyObject *_wrap_classObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17474 : PyObject *resultobj = 0;
17475 : struct classObj *arg1 = (struct classObj *) 0 ;
17476 : char *arg2 = (char *) 0 ;
17477 0 : void *argp1 = 0 ;
17478 : int res1 = 0 ;
17479 : int res2 ;
17480 0 : char *buf2 = 0 ;
17481 0 : int alloc2 = 0 ;
17482 0 : PyObject * obj0 = 0 ;
17483 0 : PyObject * obj1 = 0 ;
17484 : int result;
17485 :
17486 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_updateFromString",&obj0,&obj1)) SWIG_fail;
17487 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17488 0 : if (!SWIG_IsOK(res1)) {
17489 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_updateFromString" "', argument " "1"" of type '" "struct classObj *""'");
17490 : }
17491 0 : arg1 = (struct classObj *)(argp1);
17492 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17493 0 : if (!SWIG_IsOK(res2)) {
17494 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_updateFromString" "', argument " "2"" of type '" "char *""'");
17495 : }
17496 0 : arg2 = (char *)(buf2);
17497 : {
17498 : result = (int)classObj_updateFromString(arg1,arg2); {
17499 0 : errorObj *ms_error = msGetErrorObj();
17500 :
17501 0 : switch(ms_error->code) {
17502 : case MS_NOERR:
17503 : break;
17504 0 : case MS_NOTFOUND:
17505 0 : msResetErrorList();
17506 0 : break;
17507 : case -1:
17508 : break;
17509 0 : case MS_IOERR:
17510 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17511 0 : _raise_ms_exception();
17512 0 : msResetErrorList();
17513 0 : return NULL;
17514 : }
17515 : default:
17516 0 : _raise_ms_exception();
17517 0 : msResetErrorList();
17518 0 : return NULL;
17519 : }
17520 :
17521 : }
17522 : }
17523 : resultobj = SWIG_From_int((int)(result));
17524 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17525 : return resultobj;
17526 0 : fail:
17527 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17528 : return NULL;
17529 : }
17530 :
17531 :
17532 0 : SWIGINTERN PyObject *_wrap_classObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17533 : PyObject *resultobj = 0;
17534 : struct classObj *arg1 = (struct classObj *) 0 ;
17535 0 : void *argp1 = 0 ;
17536 : int res1 = 0 ;
17537 0 : PyObject * obj0 = 0 ;
17538 : char *result = 0 ;
17539 :
17540 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_convertToString",&obj0)) SWIG_fail;
17541 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17542 0 : if (!SWIG_IsOK(res1)) {
17543 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_convertToString" "', argument " "1"" of type '" "struct classObj *""'");
17544 : }
17545 0 : arg1 = (struct classObj *)(argp1);
17546 : {
17547 : result = (char *)classObj_convertToString(arg1); {
17548 0 : errorObj *ms_error = msGetErrorObj();
17549 :
17550 0 : switch(ms_error->code) {
17551 : case MS_NOERR:
17552 : break;
17553 0 : case MS_NOTFOUND:
17554 0 : msResetErrorList();
17555 0 : break;
17556 : case -1:
17557 : break;
17558 0 : case MS_IOERR:
17559 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17560 0 : _raise_ms_exception();
17561 0 : msResetErrorList();
17562 0 : return NULL;
17563 : }
17564 : default:
17565 0 : _raise_ms_exception();
17566 0 : msResetErrorList();
17567 0 : return NULL;
17568 : }
17569 :
17570 : }
17571 : }
17572 0 : resultobj = SWIG_FromCharPtr((const char *)result);
17573 0 : free((char*)result);
17574 0 : return resultobj;
17575 0 : fail:
17576 : return NULL;
17577 : }
17578 :
17579 :
17580 1 : SWIGINTERN PyObject *_wrap_classObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17581 : PyObject *resultobj = 0;
17582 : struct classObj *arg1 = (struct classObj *) 0 ;
17583 1 : void *argp1 = 0 ;
17584 : int res1 = 0 ;
17585 1 : PyObject * obj0 = 0 ;
17586 : classObj *result = 0 ;
17587 :
17588 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_clone",&obj0)) SWIG_fail;
17589 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17590 1 : if (!SWIG_IsOK(res1)) {
17591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_clone" "', argument " "1"" of type '" "struct classObj *""'");
17592 : }
17593 1 : arg1 = (struct classObj *)(argp1);
17594 : {
17595 1 : result = (classObj *)classObj_clone(arg1); {
17596 1 : errorObj *ms_error = msGetErrorObj();
17597 :
17598 1 : switch(ms_error->code) {
17599 : case MS_NOERR:
17600 : break;
17601 0 : case MS_NOTFOUND:
17602 0 : msResetErrorList();
17603 0 : break;
17604 : case -1:
17605 : break;
17606 0 : case MS_IOERR:
17607 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17608 0 : _raise_ms_exception();
17609 0 : msResetErrorList();
17610 0 : return NULL;
17611 : }
17612 : default:
17613 0 : _raise_ms_exception();
17614 0 : msResetErrorList();
17615 0 : return NULL;
17616 : }
17617 :
17618 : }
17619 : }
17620 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN | 0 );
17621 1 : return resultobj;
17622 0 : fail:
17623 : return NULL;
17624 : }
17625 :
17626 :
17627 0 : SWIGINTERN PyObject *_wrap_classObj_setExpression(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17628 : PyObject *resultobj = 0;
17629 : struct classObj *arg1 = (struct classObj *) 0 ;
17630 : char *arg2 = (char *) 0 ;
17631 0 : void *argp1 = 0 ;
17632 : int res1 = 0 ;
17633 : int res2 ;
17634 0 : char *buf2 = 0 ;
17635 0 : int alloc2 = 0 ;
17636 0 : PyObject * obj0 = 0 ;
17637 0 : PyObject * obj1 = 0 ;
17638 : int result;
17639 :
17640 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_setExpression",&obj0,&obj1)) SWIG_fail;
17641 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17642 0 : if (!SWIG_IsOK(res1)) {
17643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setExpression" "', argument " "1"" of type '" "struct classObj *""'");
17644 : }
17645 0 : arg1 = (struct classObj *)(argp1);
17646 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17647 0 : if (!SWIG_IsOK(res2)) {
17648 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setExpression" "', argument " "2"" of type '" "char *""'");
17649 : }
17650 0 : arg2 = (char *)(buf2);
17651 : {
17652 0 : result = (int)classObj_setExpression(arg1,arg2); {
17653 0 : errorObj *ms_error = msGetErrorObj();
17654 :
17655 0 : switch(ms_error->code) {
17656 : case MS_NOERR:
17657 : break;
17658 0 : case MS_NOTFOUND:
17659 0 : msResetErrorList();
17660 0 : break;
17661 : case -1:
17662 : break;
17663 0 : case MS_IOERR:
17664 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17665 0 : _raise_ms_exception();
17666 0 : msResetErrorList();
17667 0 : return NULL;
17668 : }
17669 : default:
17670 0 : _raise_ms_exception();
17671 0 : msResetErrorList();
17672 0 : return NULL;
17673 : }
17674 :
17675 : }
17676 : }
17677 : resultobj = SWIG_From_int((int)(result));
17678 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17679 : return resultobj;
17680 0 : fail:
17681 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17682 : return NULL;
17683 : }
17684 :
17685 :
17686 0 : SWIGINTERN PyObject *_wrap_classObj_getExpressionString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17687 : PyObject *resultobj = 0;
17688 : struct classObj *arg1 = (struct classObj *) 0 ;
17689 0 : void *argp1 = 0 ;
17690 : int res1 = 0 ;
17691 0 : PyObject * obj0 = 0 ;
17692 : char *result = 0 ;
17693 :
17694 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_getExpressionString",&obj0)) SWIG_fail;
17695 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17696 0 : if (!SWIG_IsOK(res1)) {
17697 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getExpressionString" "', argument " "1"" of type '" "struct classObj *""'");
17698 : }
17699 0 : arg1 = (struct classObj *)(argp1);
17700 : {
17701 : result = (char *)classObj_getExpressionString(arg1); {
17702 0 : errorObj *ms_error = msGetErrorObj();
17703 :
17704 0 : switch(ms_error->code) {
17705 : case MS_NOERR:
17706 : break;
17707 0 : case MS_NOTFOUND:
17708 0 : msResetErrorList();
17709 0 : break;
17710 : case -1:
17711 : break;
17712 0 : case MS_IOERR:
17713 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17714 0 : _raise_ms_exception();
17715 0 : msResetErrorList();
17716 0 : return NULL;
17717 : }
17718 : default:
17719 0 : _raise_ms_exception();
17720 0 : msResetErrorList();
17721 0 : return NULL;
17722 : }
17723 :
17724 : }
17725 : }
17726 0 : resultobj = SWIG_FromCharPtr((const char *)result);
17727 0 : free((char*)result);
17728 0 : return resultobj;
17729 0 : fail:
17730 : return NULL;
17731 : }
17732 :
17733 :
17734 0 : SWIGINTERN PyObject *_wrap_classObj_setText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17735 : PyObject *resultobj = 0;
17736 : struct classObj *arg1 = (struct classObj *) 0 ;
17737 : char *arg2 = (char *) 0 ;
17738 0 : void *argp1 = 0 ;
17739 : int res1 = 0 ;
17740 : int res2 ;
17741 0 : char *buf2 = 0 ;
17742 0 : int alloc2 = 0 ;
17743 0 : PyObject * obj0 = 0 ;
17744 0 : PyObject * obj1 = 0 ;
17745 : int result;
17746 :
17747 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_setText",&obj0,&obj1)) SWIG_fail;
17748 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17749 0 : if (!SWIG_IsOK(res1)) {
17750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setText" "', argument " "1"" of type '" "struct classObj *""'");
17751 : }
17752 0 : arg1 = (struct classObj *)(argp1);
17753 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17754 0 : if (!SWIG_IsOK(res2)) {
17755 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setText" "', argument " "2"" of type '" "char *""'");
17756 : }
17757 0 : arg2 = (char *)(buf2);
17758 : {
17759 0 : result = (int)classObj_setText(arg1,arg2); {
17760 0 : errorObj *ms_error = msGetErrorObj();
17761 :
17762 0 : switch(ms_error->code) {
17763 : case MS_NOERR:
17764 : break;
17765 0 : case MS_NOTFOUND:
17766 0 : msResetErrorList();
17767 0 : break;
17768 : case -1:
17769 : break;
17770 0 : case MS_IOERR:
17771 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17772 0 : _raise_ms_exception();
17773 0 : msResetErrorList();
17774 0 : return NULL;
17775 : }
17776 : default:
17777 0 : _raise_ms_exception();
17778 0 : msResetErrorList();
17779 0 : return NULL;
17780 : }
17781 :
17782 : }
17783 : }
17784 : resultobj = SWIG_From_int((int)(result));
17785 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17786 : return resultobj;
17787 0 : fail:
17788 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17789 : return NULL;
17790 : }
17791 :
17792 :
17793 0 : SWIGINTERN PyObject *_wrap_classObj_getTextString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17794 : PyObject *resultobj = 0;
17795 : struct classObj *arg1 = (struct classObj *) 0 ;
17796 0 : void *argp1 = 0 ;
17797 : int res1 = 0 ;
17798 0 : PyObject * obj0 = 0 ;
17799 : char *result = 0 ;
17800 :
17801 0 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_getTextString",&obj0)) SWIG_fail;
17802 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17803 0 : if (!SWIG_IsOK(res1)) {
17804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getTextString" "', argument " "1"" of type '" "struct classObj *""'");
17805 : }
17806 0 : arg1 = (struct classObj *)(argp1);
17807 : {
17808 : result = (char *)classObj_getTextString(arg1); {
17809 0 : errorObj *ms_error = msGetErrorObj();
17810 :
17811 0 : switch(ms_error->code) {
17812 : case MS_NOERR:
17813 : break;
17814 0 : case MS_NOTFOUND:
17815 0 : msResetErrorList();
17816 0 : break;
17817 : case -1:
17818 : break;
17819 0 : case MS_IOERR:
17820 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17821 0 : _raise_ms_exception();
17822 0 : msResetErrorList();
17823 0 : return NULL;
17824 : }
17825 : default:
17826 0 : _raise_ms_exception();
17827 0 : msResetErrorList();
17828 0 : return NULL;
17829 : }
17830 :
17831 : }
17832 : }
17833 0 : resultobj = SWIG_FromCharPtr((const char *)result);
17834 0 : free((char*)result);
17835 0 : return resultobj;
17836 0 : fail:
17837 : return NULL;
17838 : }
17839 :
17840 :
17841 0 : SWIGINTERN PyObject *_wrap_classObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17842 : PyObject *resultobj = 0;
17843 : struct classObj *arg1 = (struct classObj *) 0 ;
17844 : char *arg2 = (char *) 0 ;
17845 0 : void *argp1 = 0 ;
17846 : int res1 = 0 ;
17847 : int res2 ;
17848 0 : char *buf2 = 0 ;
17849 0 : int alloc2 = 0 ;
17850 0 : PyObject * obj0 = 0 ;
17851 0 : PyObject * obj1 = 0 ;
17852 : char *result = 0 ;
17853 :
17854 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getMetaData",&obj0,&obj1)) SWIG_fail;
17855 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17856 0 : if (!SWIG_IsOK(res1)) {
17857 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getMetaData" "', argument " "1"" of type '" "struct classObj *""'");
17858 : }
17859 0 : arg1 = (struct classObj *)(argp1);
17860 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17861 0 : if (!SWIG_IsOK(res2)) {
17862 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_getMetaData" "', argument " "2"" of type '" "char *""'");
17863 : }
17864 0 : arg2 = (char *)(buf2);
17865 : {
17866 0 : result = (char *)classObj_getMetaData(arg1,arg2); {
17867 0 : errorObj *ms_error = msGetErrorObj();
17868 :
17869 0 : switch(ms_error->code) {
17870 : case MS_NOERR:
17871 : break;
17872 0 : case MS_NOTFOUND:
17873 0 : msResetErrorList();
17874 0 : break;
17875 : case -1:
17876 : break;
17877 0 : case MS_IOERR:
17878 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17879 0 : _raise_ms_exception();
17880 0 : msResetErrorList();
17881 0 : return NULL;
17882 : }
17883 : default:
17884 0 : _raise_ms_exception();
17885 0 : msResetErrorList();
17886 0 : return NULL;
17887 : }
17888 :
17889 : }
17890 : }
17891 0 : resultobj = SWIG_FromCharPtr((const char *)result);
17892 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17893 : return resultobj;
17894 0 : fail:
17895 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17896 : return NULL;
17897 : }
17898 :
17899 :
17900 0 : SWIGINTERN PyObject *_wrap_classObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17901 : PyObject *resultobj = 0;
17902 : struct classObj *arg1 = (struct classObj *) 0 ;
17903 : char *arg2 = (char *) 0 ;
17904 : char *arg3 = (char *) 0 ;
17905 0 : void *argp1 = 0 ;
17906 : int res1 = 0 ;
17907 : int res2 ;
17908 0 : char *buf2 = 0 ;
17909 0 : int alloc2 = 0 ;
17910 : int res3 ;
17911 0 : char *buf3 = 0 ;
17912 0 : int alloc3 = 0 ;
17913 0 : PyObject * obj0 = 0 ;
17914 0 : PyObject * obj1 = 0 ;
17915 0 : PyObject * obj2 = 0 ;
17916 : int result;
17917 :
17918 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:classObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
17919 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17920 0 : if (!SWIG_IsOK(res1)) {
17921 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_setMetaData" "', argument " "1"" of type '" "struct classObj *""'");
17922 : }
17923 0 : arg1 = (struct classObj *)(argp1);
17924 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17925 0 : if (!SWIG_IsOK(res2)) {
17926 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_setMetaData" "', argument " "2"" of type '" "char *""'");
17927 : }
17928 0 : arg2 = (char *)(buf2);
17929 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
17930 0 : if (!SWIG_IsOK(res3)) {
17931 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_setMetaData" "', argument " "3"" of type '" "char *""'");
17932 : }
17933 0 : arg3 = (char *)(buf3);
17934 : {
17935 : result = (int)classObj_setMetaData(arg1,arg2,arg3); {
17936 0 : errorObj *ms_error = msGetErrorObj();
17937 :
17938 0 : switch(ms_error->code) {
17939 : case MS_NOERR:
17940 : break;
17941 0 : case MS_NOTFOUND:
17942 0 : msResetErrorList();
17943 0 : break;
17944 : case -1:
17945 : break;
17946 0 : case MS_IOERR:
17947 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17948 0 : _raise_ms_exception();
17949 0 : msResetErrorList();
17950 0 : return NULL;
17951 : }
17952 : default:
17953 0 : _raise_ms_exception();
17954 0 : msResetErrorList();
17955 0 : return NULL;
17956 : }
17957 :
17958 : }
17959 : }
17960 : resultobj = SWIG_From_int((int)(result));
17961 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17962 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
17963 : return resultobj;
17964 0 : fail:
17965 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17966 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
17967 : return NULL;
17968 : }
17969 :
17970 :
17971 1 : SWIGINTERN PyObject *_wrap_classObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17972 : PyObject *resultobj = 0;
17973 : struct classObj *arg1 = (struct classObj *) 0 ;
17974 1 : void *argp1 = 0 ;
17975 : int res1 = 0 ;
17976 1 : PyObject * obj0 = 0 ;
17977 : char *result = 0 ;
17978 :
17979 1 : if (!PyArg_ParseTuple(args,(char *)"O:classObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
17980 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
17981 1 : if (!SWIG_IsOK(res1)) {
17982 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct classObj *""'");
17983 : }
17984 1 : arg1 = (struct classObj *)(argp1);
17985 : {
17986 : result = (char *)classObj_getFirstMetaDataKey(arg1); {
17987 1 : errorObj *ms_error = msGetErrorObj();
17988 :
17989 1 : switch(ms_error->code) {
17990 : case MS_NOERR:
17991 : break;
17992 0 : case MS_NOTFOUND:
17993 0 : msResetErrorList();
17994 0 : break;
17995 : case -1:
17996 : break;
17997 0 : case MS_IOERR:
17998 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
17999 0 : _raise_ms_exception();
18000 0 : msResetErrorList();
18001 0 : return NULL;
18002 : }
18003 : default:
18004 0 : _raise_ms_exception();
18005 0 : msResetErrorList();
18006 0 : return NULL;
18007 : }
18008 :
18009 : }
18010 : }
18011 1 : resultobj = SWIG_FromCharPtr((const char *)result);
18012 1 : return resultobj;
18013 0 : fail:
18014 : return NULL;
18015 : }
18016 :
18017 :
18018 1 : SWIGINTERN PyObject *_wrap_classObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18019 : PyObject *resultobj = 0;
18020 : struct classObj *arg1 = (struct classObj *) 0 ;
18021 : char *arg2 = (char *) 0 ;
18022 1 : void *argp1 = 0 ;
18023 : int res1 = 0 ;
18024 : int res2 ;
18025 1 : char *buf2 = 0 ;
18026 1 : int alloc2 = 0 ;
18027 1 : PyObject * obj0 = 0 ;
18028 1 : PyObject * obj1 = 0 ;
18029 : char *result = 0 ;
18030 :
18031 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
18032 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18033 1 : if (!SWIG_IsOK(res1)) {
18034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct classObj *""'");
18035 : }
18036 1 : arg1 = (struct classObj *)(argp1);
18037 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
18038 1 : if (!SWIG_IsOK(res2)) {
18039 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
18040 : }
18041 1 : arg2 = (char *)(buf2);
18042 : {
18043 : result = (char *)classObj_getNextMetaDataKey(arg1,arg2); {
18044 1 : errorObj *ms_error = msGetErrorObj();
18045 :
18046 1 : switch(ms_error->code) {
18047 : case MS_NOERR:
18048 : break;
18049 0 : case MS_NOTFOUND:
18050 0 : msResetErrorList();
18051 0 : break;
18052 : case -1:
18053 : break;
18054 0 : case MS_IOERR:
18055 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18056 0 : _raise_ms_exception();
18057 0 : msResetErrorList();
18058 0 : return NULL;
18059 : }
18060 : default:
18061 0 : _raise_ms_exception();
18062 0 : msResetErrorList();
18063 0 : return NULL;
18064 : }
18065 :
18066 : }
18067 : }
18068 1 : resultobj = SWIG_FromCharPtr((const char *)result);
18069 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
18070 : return resultobj;
18071 0 : fail:
18072 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
18073 : return NULL;
18074 : }
18075 :
18076 :
18077 0 : SWIGINTERN PyObject *_wrap_classObj_drawLegendIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18078 : PyObject *resultobj = 0;
18079 : struct classObj *arg1 = (struct classObj *) 0 ;
18080 : mapObj *arg2 = (mapObj *) 0 ;
18081 : layerObj *arg3 = (layerObj *) 0 ;
18082 : int arg4 ;
18083 : int arg5 ;
18084 : imageObj *arg6 = (imageObj *) 0 ;
18085 : int arg7 ;
18086 : int arg8 ;
18087 0 : void *argp1 = 0 ;
18088 : int res1 = 0 ;
18089 0 : void *argp2 = 0 ;
18090 : int res2 = 0 ;
18091 0 : void *argp3 = 0 ;
18092 : int res3 = 0 ;
18093 : int val4 ;
18094 : int ecode4 = 0 ;
18095 : int val5 ;
18096 : int ecode5 = 0 ;
18097 0 : void *argp6 = 0 ;
18098 : int res6 = 0 ;
18099 : int val7 ;
18100 : int ecode7 = 0 ;
18101 : int val8 ;
18102 : int ecode8 = 0 ;
18103 0 : PyObject * obj0 = 0 ;
18104 0 : PyObject * obj1 = 0 ;
18105 0 : PyObject * obj2 = 0 ;
18106 0 : PyObject * obj3 = 0 ;
18107 0 : PyObject * obj4 = 0 ;
18108 0 : PyObject * obj5 = 0 ;
18109 0 : PyObject * obj6 = 0 ;
18110 0 : PyObject * obj7 = 0 ;
18111 : int result;
18112 :
18113 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:classObj_drawLegendIcon",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
18114 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18115 0 : if (!SWIG_IsOK(res1)) {
18116 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_drawLegendIcon" "', argument " "1"" of type '" "struct classObj *""'");
18117 : }
18118 0 : arg1 = (struct classObj *)(argp1);
18119 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
18120 0 : if (!SWIG_IsOK(res2)) {
18121 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_drawLegendIcon" "', argument " "2"" of type '" "mapObj *""'");
18122 : }
18123 0 : arg2 = (mapObj *)(argp2);
18124 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 | 0 );
18125 0 : if (!SWIG_IsOK(res3)) {
18126 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_drawLegendIcon" "', argument " "3"" of type '" "layerObj *""'");
18127 : }
18128 0 : arg3 = (layerObj *)(argp3);
18129 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18130 0 : if (!SWIG_IsOK(ecode4)) {
18131 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "classObj_drawLegendIcon" "', argument " "4"" of type '" "int""'");
18132 : }
18133 : arg4 = (int)(val4);
18134 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
18135 0 : if (!SWIG_IsOK(ecode5)) {
18136 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "classObj_drawLegendIcon" "', argument " "5"" of type '" "int""'");
18137 : }
18138 : arg5 = (int)(val5);
18139 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_imageObj, 0 | 0 );
18140 0 : if (!SWIG_IsOK(res6)) {
18141 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "classObj_drawLegendIcon" "', argument " "6"" of type '" "imageObj *""'");
18142 : }
18143 0 : arg6 = (imageObj *)(argp6);
18144 0 : ecode7 = SWIG_AsVal_int(obj6, &val7);
18145 0 : if (!SWIG_IsOK(ecode7)) {
18146 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "classObj_drawLegendIcon" "', argument " "7"" of type '" "int""'");
18147 : }
18148 : arg7 = (int)(val7);
18149 0 : ecode8 = SWIG_AsVal_int(obj7, &val8);
18150 0 : if (!SWIG_IsOK(ecode8)) {
18151 0 : SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "classObj_drawLegendIcon" "', argument " "8"" of type '" "int""'");
18152 : }
18153 : arg8 = (int)(val8);
18154 : {
18155 0 : result = (int)classObj_drawLegendIcon(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); {
18156 0 : errorObj *ms_error = msGetErrorObj();
18157 :
18158 0 : switch(ms_error->code) {
18159 : case MS_NOERR:
18160 : break;
18161 0 : case MS_NOTFOUND:
18162 0 : msResetErrorList();
18163 0 : break;
18164 : case -1:
18165 : break;
18166 0 : case MS_IOERR:
18167 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18168 0 : _raise_ms_exception();
18169 0 : msResetErrorList();
18170 0 : return NULL;
18171 : }
18172 : default:
18173 0 : _raise_ms_exception();
18174 0 : msResetErrorList();
18175 0 : return NULL;
18176 : }
18177 :
18178 : }
18179 : }
18180 : resultobj = SWIG_From_int((int)(result));
18181 0 : return resultobj;
18182 0 : fail:
18183 : return NULL;
18184 : }
18185 :
18186 :
18187 1 : SWIGINTERN PyObject *_wrap_classObj_createLegendIcon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 : PyObject *resultobj = 0;
18189 : struct classObj *arg1 = (struct classObj *) 0 ;
18190 : mapObj *arg2 = (mapObj *) 0 ;
18191 : layerObj *arg3 = (layerObj *) 0 ;
18192 : int arg4 ;
18193 : int arg5 ;
18194 1 : void *argp1 = 0 ;
18195 : int res1 = 0 ;
18196 1 : void *argp2 = 0 ;
18197 : int res2 = 0 ;
18198 1 : void *argp3 = 0 ;
18199 : int res3 = 0 ;
18200 : int val4 ;
18201 : int ecode4 = 0 ;
18202 : int val5 ;
18203 : int ecode5 = 0 ;
18204 1 : PyObject * obj0 = 0 ;
18205 1 : PyObject * obj1 = 0 ;
18206 1 : PyObject * obj2 = 0 ;
18207 1 : PyObject * obj3 = 0 ;
18208 1 : PyObject * obj4 = 0 ;
18209 : imageObj *result = 0 ;
18210 :
18211 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:classObj_createLegendIcon",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18212 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18213 1 : if (!SWIG_IsOK(res1)) {
18214 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_createLegendIcon" "', argument " "1"" of type '" "struct classObj *""'");
18215 : }
18216 1 : arg1 = (struct classObj *)(argp1);
18217 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
18218 1 : if (!SWIG_IsOK(res2)) {
18219 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_createLegendIcon" "', argument " "2"" of type '" "mapObj *""'");
18220 : }
18221 1 : arg2 = (mapObj *)(argp2);
18222 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 | 0 );
18223 1 : if (!SWIG_IsOK(res3)) {
18224 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "classObj_createLegendIcon" "', argument " "3"" of type '" "layerObj *""'");
18225 : }
18226 1 : arg3 = (layerObj *)(argp3);
18227 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
18228 1 : if (!SWIG_IsOK(ecode4)) {
18229 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "classObj_createLegendIcon" "', argument " "4"" of type '" "int""'");
18230 : }
18231 : arg4 = (int)(val4);
18232 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
18233 1 : if (!SWIG_IsOK(ecode5)) {
18234 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "classObj_createLegendIcon" "', argument " "5"" of type '" "int""'");
18235 : }
18236 : arg5 = (int)(val5);
18237 : {
18238 : result = (imageObj *)classObj_createLegendIcon(arg1,arg2,arg3,arg4,arg5); {
18239 1 : errorObj *ms_error = msGetErrorObj();
18240 :
18241 1 : switch(ms_error->code) {
18242 : case MS_NOERR:
18243 : break;
18244 0 : case MS_NOTFOUND:
18245 0 : msResetErrorList();
18246 0 : break;
18247 : case -1:
18248 : break;
18249 0 : case MS_IOERR:
18250 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18251 0 : _raise_ms_exception();
18252 0 : msResetErrorList();
18253 0 : return NULL;
18254 : }
18255 : default:
18256 0 : _raise_ms_exception();
18257 0 : msResetErrorList();
18258 0 : return NULL;
18259 : }
18260 :
18261 : }
18262 : }
18263 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
18264 1 : return resultobj;
18265 0 : fail:
18266 : return NULL;
18267 : }
18268 :
18269 :
18270 1 : SWIGINTERN PyObject *_wrap_classObj_getLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18271 : PyObject *resultobj = 0;
18272 : struct classObj *arg1 = (struct classObj *) 0 ;
18273 : int arg2 ;
18274 1 : void *argp1 = 0 ;
18275 : int res1 = 0 ;
18276 : int val2 ;
18277 : int ecode2 = 0 ;
18278 1 : PyObject * obj0 = 0 ;
18279 1 : PyObject * obj1 = 0 ;
18280 : labelObj *result = 0 ;
18281 :
18282 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getLabel",&obj0,&obj1)) SWIG_fail;
18283 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18284 1 : if (!SWIG_IsOK(res1)) {
18285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getLabel" "', argument " "1"" of type '" "struct classObj *""'");
18286 : }
18287 1 : arg1 = (struct classObj *)(argp1);
18288 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18289 1 : if (!SWIG_IsOK(ecode2)) {
18290 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_getLabel" "', argument " "2"" of type '" "int""'");
18291 : }
18292 : arg2 = (int)(val2);
18293 : {
18294 1 : result = (labelObj *)classObj_getLabel(arg1,arg2); {
18295 1 : errorObj *ms_error = msGetErrorObj();
18296 :
18297 1 : switch(ms_error->code) {
18298 : case MS_NOERR:
18299 : break;
18300 0 : case MS_NOTFOUND:
18301 0 : msResetErrorList();
18302 0 : break;
18303 : case -1:
18304 : break;
18305 0 : case MS_IOERR:
18306 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18307 0 : _raise_ms_exception();
18308 0 : msResetErrorList();
18309 0 : return NULL;
18310 : }
18311 : default:
18312 0 : _raise_ms_exception();
18313 0 : msResetErrorList();
18314 0 : return NULL;
18315 : }
18316 :
18317 : }
18318 : }
18319 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_OWN | 0 );
18320 1 : return resultobj;
18321 0 : fail:
18322 : return NULL;
18323 : }
18324 :
18325 :
18326 1 : SWIGINTERN PyObject *_wrap_classObj_addLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18327 : PyObject *resultobj = 0;
18328 : struct classObj *arg1 = (struct classObj *) 0 ;
18329 : labelObj *arg2 = (labelObj *) 0 ;
18330 1 : void *argp1 = 0 ;
18331 : int res1 = 0 ;
18332 1 : void *argp2 = 0 ;
18333 : int res2 = 0 ;
18334 1 : PyObject * obj0 = 0 ;
18335 1 : PyObject * obj1 = 0 ;
18336 : int result;
18337 :
18338 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_addLabel",&obj0,&obj1)) SWIG_fail;
18339 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18340 1 : if (!SWIG_IsOK(res1)) {
18341 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_addLabel" "', argument " "1"" of type '" "struct classObj *""'");
18342 : }
18343 1 : arg1 = (struct classObj *)(argp1);
18344 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelObj, 0 | 0 );
18345 1 : if (!SWIG_IsOK(res2)) {
18346 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_addLabel" "', argument " "2"" of type '" "labelObj *""'");
18347 : }
18348 1 : arg2 = (labelObj *)(argp2);
18349 : {
18350 : result = (int)classObj_addLabel(arg1,arg2); {
18351 1 : errorObj *ms_error = msGetErrorObj();
18352 :
18353 1 : switch(ms_error->code) {
18354 : case MS_NOERR:
18355 : break;
18356 0 : case MS_NOTFOUND:
18357 0 : msResetErrorList();
18358 0 : break;
18359 : case -1:
18360 : break;
18361 0 : case MS_IOERR:
18362 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18363 0 : _raise_ms_exception();
18364 0 : msResetErrorList();
18365 0 : return NULL;
18366 : }
18367 : default:
18368 0 : _raise_ms_exception();
18369 0 : msResetErrorList();
18370 0 : return NULL;
18371 : }
18372 :
18373 : }
18374 : }
18375 : resultobj = SWIG_From_int((int)(result));
18376 1 : return resultobj;
18377 0 : fail:
18378 : return NULL;
18379 : }
18380 :
18381 :
18382 0 : SWIGINTERN PyObject *_wrap_classObj_removeLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18383 : PyObject *resultobj = 0;
18384 : struct classObj *arg1 = (struct classObj *) 0 ;
18385 : int arg2 ;
18386 0 : void *argp1 = 0 ;
18387 : int res1 = 0 ;
18388 : int val2 ;
18389 : int ecode2 = 0 ;
18390 0 : PyObject * obj0 = 0 ;
18391 0 : PyObject * obj1 = 0 ;
18392 : labelObj *result = 0 ;
18393 :
18394 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_removeLabel",&obj0,&obj1)) SWIG_fail;
18395 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18396 0 : if (!SWIG_IsOK(res1)) {
18397 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_removeLabel" "', argument " "1"" of type '" "struct classObj *""'");
18398 : }
18399 0 : arg1 = (struct classObj *)(argp1);
18400 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18401 0 : if (!SWIG_IsOK(ecode2)) {
18402 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_removeLabel" "', argument " "2"" of type '" "int""'");
18403 : }
18404 : arg2 = (int)(val2);
18405 : {
18406 0 : result = (labelObj *)classObj_removeLabel(arg1,arg2); {
18407 0 : errorObj *ms_error = msGetErrorObj();
18408 :
18409 0 : switch(ms_error->code) {
18410 : case MS_NOERR:
18411 : break;
18412 0 : case MS_NOTFOUND:
18413 0 : msResetErrorList();
18414 0 : break;
18415 : case -1:
18416 : break;
18417 0 : case MS_IOERR:
18418 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18419 0 : _raise_ms_exception();
18420 0 : msResetErrorList();
18421 0 : return NULL;
18422 : }
18423 : default:
18424 0 : _raise_ms_exception();
18425 0 : msResetErrorList();
18426 0 : return NULL;
18427 : }
18428 :
18429 : }
18430 : }
18431 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, SWIG_POINTER_OWN | 0 );
18432 0 : return resultobj;
18433 0 : fail:
18434 : return NULL;
18435 : }
18436 :
18437 :
18438 1 : SWIGINTERN PyObject *_wrap_classObj_getStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18439 : PyObject *resultobj = 0;
18440 : struct classObj *arg1 = (struct classObj *) 0 ;
18441 : int arg2 ;
18442 1 : void *argp1 = 0 ;
18443 : int res1 = 0 ;
18444 : int val2 ;
18445 : int ecode2 = 0 ;
18446 1 : PyObject * obj0 = 0 ;
18447 1 : PyObject * obj1 = 0 ;
18448 : styleObj *result = 0 ;
18449 :
18450 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_getStyle",&obj0,&obj1)) SWIG_fail;
18451 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18452 1 : if (!SWIG_IsOK(res1)) {
18453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_getStyle" "', argument " "1"" of type '" "struct classObj *""'");
18454 : }
18455 1 : arg1 = (struct classObj *)(argp1);
18456 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18457 1 : if (!SWIG_IsOK(ecode2)) {
18458 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_getStyle" "', argument " "2"" of type '" "int""'");
18459 : }
18460 : arg2 = (int)(val2);
18461 : {
18462 1 : result = (styleObj *)classObj_getStyle(arg1,arg2); {
18463 1 : errorObj *ms_error = msGetErrorObj();
18464 :
18465 1 : switch(ms_error->code) {
18466 : case MS_NOERR:
18467 : break;
18468 0 : case MS_NOTFOUND:
18469 0 : msResetErrorList();
18470 0 : break;
18471 : case -1:
18472 : break;
18473 0 : case MS_IOERR:
18474 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18475 0 : _raise_ms_exception();
18476 0 : msResetErrorList();
18477 0 : return NULL;
18478 : }
18479 : default:
18480 0 : _raise_ms_exception();
18481 0 : msResetErrorList();
18482 0 : return NULL;
18483 : }
18484 :
18485 : }
18486 : }
18487 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN | 0 );
18488 1 : return resultobj;
18489 0 : fail:
18490 : return NULL;
18491 : }
18492 :
18493 :
18494 1 : SWIGINTERN PyObject *_wrap_classObj_insertStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18495 : PyObject *resultobj = 0;
18496 : struct classObj *arg1 = (struct classObj *) 0 ;
18497 : styleObj *arg2 = (styleObj *) 0 ;
18498 : int arg3 = (int) -1 ;
18499 1 : void *argp1 = 0 ;
18500 : int res1 = 0 ;
18501 1 : void *argp2 = 0 ;
18502 : int res2 = 0 ;
18503 : int val3 ;
18504 : int ecode3 = 0 ;
18505 1 : PyObject * obj0 = 0 ;
18506 1 : PyObject * obj1 = 0 ;
18507 1 : PyObject * obj2 = 0 ;
18508 : int result;
18509 :
18510 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:classObj_insertStyle",&obj0,&obj1,&obj2)) SWIG_fail;
18511 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18512 1 : if (!SWIG_IsOK(res1)) {
18513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_insertStyle" "', argument " "1"" of type '" "struct classObj *""'");
18514 : }
18515 1 : arg1 = (struct classObj *)(argp1);
18516 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_styleObj, 0 | 0 );
18517 1 : if (!SWIG_IsOK(res2)) {
18518 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "classObj_insertStyle" "', argument " "2"" of type '" "styleObj *""'");
18519 : }
18520 1 : arg2 = (styleObj *)(argp2);
18521 1 : if (obj2) {
18522 : ecode3 = SWIG_AsVal_int(obj2, &val3);
18523 1 : if (!SWIG_IsOK(ecode3)) {
18524 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "classObj_insertStyle" "', argument " "3"" of type '" "int""'");
18525 : }
18526 : arg3 = (int)(val3);
18527 : }
18528 : {
18529 : result = (int)classObj_insertStyle(arg1,arg2,arg3); {
18530 1 : errorObj *ms_error = msGetErrorObj();
18531 :
18532 1 : switch(ms_error->code) {
18533 : case MS_NOERR:
18534 : break;
18535 0 : case MS_NOTFOUND:
18536 0 : msResetErrorList();
18537 0 : break;
18538 : case -1:
18539 : break;
18540 0 : case MS_IOERR:
18541 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18542 0 : _raise_ms_exception();
18543 0 : msResetErrorList();
18544 0 : return NULL;
18545 : }
18546 : default:
18547 1 : _raise_ms_exception();
18548 1 : msResetErrorList();
18549 1 : return NULL;
18550 : }
18551 :
18552 : }
18553 : }
18554 : resultobj = SWIG_From_int((int)(result));
18555 1 : return resultobj;
18556 0 : fail:
18557 : return NULL;
18558 : }
18559 :
18560 :
18561 1 : SWIGINTERN PyObject *_wrap_classObj_removeStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18562 : PyObject *resultobj = 0;
18563 : struct classObj *arg1 = (struct classObj *) 0 ;
18564 : int arg2 ;
18565 1 : void *argp1 = 0 ;
18566 : int res1 = 0 ;
18567 : int val2 ;
18568 : int ecode2 = 0 ;
18569 1 : PyObject * obj0 = 0 ;
18570 1 : PyObject * obj1 = 0 ;
18571 : styleObj *result = 0 ;
18572 :
18573 1 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_removeStyle",&obj0,&obj1)) SWIG_fail;
18574 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18575 1 : if (!SWIG_IsOK(res1)) {
18576 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_removeStyle" "', argument " "1"" of type '" "struct classObj *""'");
18577 : }
18578 1 : arg1 = (struct classObj *)(argp1);
18579 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18580 1 : if (!SWIG_IsOK(ecode2)) {
18581 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_removeStyle" "', argument " "2"" of type '" "int""'");
18582 : }
18583 : arg2 = (int)(val2);
18584 : {
18585 1 : result = (styleObj *)classObj_removeStyle(arg1,arg2); {
18586 1 : errorObj *ms_error = msGetErrorObj();
18587 :
18588 1 : switch(ms_error->code) {
18589 : case MS_NOERR:
18590 : break;
18591 0 : case MS_NOTFOUND:
18592 0 : msResetErrorList();
18593 0 : break;
18594 : case -1:
18595 : break;
18596 0 : case MS_IOERR:
18597 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18598 0 : _raise_ms_exception();
18599 0 : msResetErrorList();
18600 0 : return NULL;
18601 : }
18602 : default:
18603 0 : _raise_ms_exception();
18604 0 : msResetErrorList();
18605 0 : return NULL;
18606 : }
18607 :
18608 : }
18609 : }
18610 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_styleObj, SWIG_POINTER_OWN | 0 );
18611 1 : return resultobj;
18612 0 : fail:
18613 : return NULL;
18614 : }
18615 :
18616 :
18617 0 : SWIGINTERN PyObject *_wrap_classObj_moveStyleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18618 : PyObject *resultobj = 0;
18619 : struct classObj *arg1 = (struct classObj *) 0 ;
18620 : int arg2 ;
18621 0 : void *argp1 = 0 ;
18622 : int res1 = 0 ;
18623 : int val2 ;
18624 : int ecode2 = 0 ;
18625 0 : PyObject * obj0 = 0 ;
18626 0 : PyObject * obj1 = 0 ;
18627 : int result;
18628 :
18629 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_moveStyleUp",&obj0,&obj1)) SWIG_fail;
18630 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18631 0 : if (!SWIG_IsOK(res1)) {
18632 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_moveStyleUp" "', argument " "1"" of type '" "struct classObj *""'");
18633 : }
18634 0 : arg1 = (struct classObj *)(argp1);
18635 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18636 0 : if (!SWIG_IsOK(ecode2)) {
18637 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_moveStyleUp" "', argument " "2"" of type '" "int""'");
18638 : }
18639 : arg2 = (int)(val2);
18640 : {
18641 : result = (int)classObj_moveStyleUp(arg1,arg2); {
18642 0 : errorObj *ms_error = msGetErrorObj();
18643 :
18644 0 : switch(ms_error->code) {
18645 : case MS_NOERR:
18646 : break;
18647 0 : case MS_NOTFOUND:
18648 0 : msResetErrorList();
18649 0 : break;
18650 : case -1:
18651 : break;
18652 0 : case MS_IOERR:
18653 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18654 0 : _raise_ms_exception();
18655 0 : msResetErrorList();
18656 0 : return NULL;
18657 : }
18658 : default:
18659 0 : _raise_ms_exception();
18660 0 : msResetErrorList();
18661 0 : return NULL;
18662 : }
18663 :
18664 : }
18665 : }
18666 : resultobj = SWIG_From_int((int)(result));
18667 0 : return resultobj;
18668 0 : fail:
18669 : return NULL;
18670 : }
18671 :
18672 :
18673 0 : SWIGINTERN PyObject *_wrap_classObj_moveStyleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18674 : PyObject *resultobj = 0;
18675 : struct classObj *arg1 = (struct classObj *) 0 ;
18676 : int arg2 ;
18677 0 : void *argp1 = 0 ;
18678 : int res1 = 0 ;
18679 : int val2 ;
18680 : int ecode2 = 0 ;
18681 0 : PyObject * obj0 = 0 ;
18682 0 : PyObject * obj1 = 0 ;
18683 : int result;
18684 :
18685 0 : if (!PyArg_ParseTuple(args,(char *)"OO:classObj_moveStyleDown",&obj0,&obj1)) SWIG_fail;
18686 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_classObj, 0 | 0 );
18687 0 : if (!SWIG_IsOK(res1)) {
18688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "classObj_moveStyleDown" "', argument " "1"" of type '" "struct classObj *""'");
18689 : }
18690 0 : arg1 = (struct classObj *)(argp1);
18691 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
18692 0 : if (!SWIG_IsOK(ecode2)) {
18693 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "classObj_moveStyleDown" "', argument " "2"" of type '" "int""'");
18694 : }
18695 : arg2 = (int)(val2);
18696 : {
18697 : result = (int)classObj_moveStyleDown(arg1,arg2); {
18698 0 : errorObj *ms_error = msGetErrorObj();
18699 :
18700 0 : switch(ms_error->code) {
18701 : case MS_NOERR:
18702 : break;
18703 0 : case MS_NOTFOUND:
18704 0 : msResetErrorList();
18705 0 : break;
18706 : case -1:
18707 : break;
18708 0 : case MS_IOERR:
18709 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18710 0 : _raise_ms_exception();
18711 0 : msResetErrorList();
18712 0 : return NULL;
18713 : }
18714 : default:
18715 0 : _raise_ms_exception();
18716 0 : msResetErrorList();
18717 0 : return NULL;
18718 : }
18719 :
18720 : }
18721 : }
18722 : resultobj = SWIG_From_int((int)(result));
18723 0 : return resultobj;
18724 0 : fail:
18725 : return NULL;
18726 : }
18727 :
18728 :
18729 1 : SWIGINTERN PyObject *classObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18730 : PyObject *obj;
18731 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
18732 1 : SWIG_TypeNewClientData(SWIGTYPE_p_classObj, SWIG_NewClientData(obj));
18733 1 : return SWIG_Py_Void();
18734 : }
18735 :
18736 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_textsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 : PyObject *resultobj = 0;
18738 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18739 0 : void *argp1 = 0 ;
18740 : int res1 = 0 ;
18741 0 : PyObject * obj0 = 0 ;
18742 : textSymbolObj **result = 0 ;
18743 :
18744 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_textsymbols_get",&obj0)) SWIG_fail;
18745 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18746 0 : if (!SWIG_IsOK(res1)) {
18747 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_textsymbols_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18748 : }
18749 0 : arg1 = (labelCacheMemberObj *)(argp1);
18750 0 : result = (textSymbolObj **) ((arg1)->textsymbols);
18751 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_textSymbolObj, 0 | 0 );
18752 0 : return resultobj;
18753 0 : fail:
18754 : return NULL;
18755 : }
18756 :
18757 :
18758 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_numtextsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18759 : PyObject *resultobj = 0;
18760 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18761 0 : void *argp1 = 0 ;
18762 : int res1 = 0 ;
18763 0 : PyObject * obj0 = 0 ;
18764 : int result;
18765 :
18766 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_numtextsymbols_get",&obj0)) SWIG_fail;
18767 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18768 0 : if (!SWIG_IsOK(res1)) {
18769 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_numtextsymbols_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18770 : }
18771 0 : arg1 = (labelCacheMemberObj *)(argp1);
18772 0 : result = (int) ((arg1)->numtextsymbols);
18773 : resultobj = SWIG_From_int((int)(result));
18774 0 : return resultobj;
18775 0 : fail:
18776 : return NULL;
18777 : }
18778 :
18779 :
18780 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_layerindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18781 : PyObject *resultobj = 0;
18782 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18783 0 : void *argp1 = 0 ;
18784 : int res1 = 0 ;
18785 0 : PyObject * obj0 = 0 ;
18786 : int result;
18787 :
18788 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_layerindex_get",&obj0)) SWIG_fail;
18789 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18790 0 : if (!SWIG_IsOK(res1)) {
18791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_layerindex_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18792 : }
18793 0 : arg1 = (labelCacheMemberObj *)(argp1);
18794 0 : result = (int) ((arg1)->layerindex);
18795 : resultobj = SWIG_From_int((int)(result));
18796 0 : return resultobj;
18797 0 : fail:
18798 : return NULL;
18799 : }
18800 :
18801 :
18802 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18803 : PyObject *resultobj = 0;
18804 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18805 0 : void *argp1 = 0 ;
18806 : int res1 = 0 ;
18807 0 : PyObject * obj0 = 0 ;
18808 : int result;
18809 :
18810 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_classindex_get",&obj0)) SWIG_fail;
18811 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18812 0 : if (!SWIG_IsOK(res1)) {
18813 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_classindex_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18814 : }
18815 0 : arg1 = (labelCacheMemberObj *)(argp1);
18816 0 : result = (int) ((arg1)->classindex);
18817 : resultobj = SWIG_From_int((int)(result));
18818 0 : return resultobj;
18819 0 : fail:
18820 : return NULL;
18821 : }
18822 :
18823 :
18824 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_point_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18825 : PyObject *resultobj = 0;
18826 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18827 0 : void *argp1 = 0 ;
18828 : int res1 = 0 ;
18829 0 : PyObject * obj0 = 0 ;
18830 : pointObj *result = 0 ;
18831 :
18832 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_point_get",&obj0)) SWIG_fail;
18833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18834 0 : if (!SWIG_IsOK(res1)) {
18835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_point_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18836 : }
18837 0 : arg1 = (labelCacheMemberObj *)(argp1);
18838 0 : result = (pointObj *)& ((arg1)->point);
18839 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, 0 | 0 );
18840 0 : return resultobj;
18841 0 : fail:
18842 : return NULL;
18843 : }
18844 :
18845 :
18846 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_bbox_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18847 : PyObject *resultobj = 0;
18848 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18849 0 : void *argp1 = 0 ;
18850 : int res1 = 0 ;
18851 0 : PyObject * obj0 = 0 ;
18852 : rectObj *result = 0 ;
18853 :
18854 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_bbox_get",&obj0)) SWIG_fail;
18855 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18856 0 : if (!SWIG_IsOK(res1)) {
18857 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_bbox_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18858 : }
18859 0 : arg1 = (labelCacheMemberObj *)(argp1);
18860 0 : result = (rectObj *)& ((arg1)->bbox);
18861 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
18862 0 : return resultobj;
18863 0 : fail:
18864 : return NULL;
18865 : }
18866 :
18867 :
18868 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18869 : PyObject *resultobj = 0;
18870 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18871 0 : void *argp1 = 0 ;
18872 : int res1 = 0 ;
18873 0 : PyObject * obj0 = 0 ;
18874 : int result;
18875 :
18876 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_status_get",&obj0)) SWIG_fail;
18877 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18878 0 : if (!SWIG_IsOK(res1)) {
18879 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_status_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18880 : }
18881 0 : arg1 = (labelCacheMemberObj *)(argp1);
18882 0 : result = (int) ((arg1)->status);
18883 : resultobj = SWIG_From_int((int)(result));
18884 0 : return resultobj;
18885 0 : fail:
18886 : return NULL;
18887 : }
18888 :
18889 :
18890 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_markerid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18891 : PyObject *resultobj = 0;
18892 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18893 0 : void *argp1 = 0 ;
18894 : int res1 = 0 ;
18895 0 : PyObject * obj0 = 0 ;
18896 : int result;
18897 :
18898 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_markerid_get",&obj0)) SWIG_fail;
18899 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18900 0 : if (!SWIG_IsOK(res1)) {
18901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_markerid_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18902 : }
18903 0 : arg1 = (labelCacheMemberObj *)(argp1);
18904 0 : result = (int) ((arg1)->markerid);
18905 : resultobj = SWIG_From_int((int)(result));
18906 0 : return resultobj;
18907 0 : fail:
18908 : return NULL;
18909 : }
18910 :
18911 :
18912 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_leaderline_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18913 : PyObject *resultobj = 0;
18914 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18915 0 : void *argp1 = 0 ;
18916 : int res1 = 0 ;
18917 0 : PyObject * obj0 = 0 ;
18918 : lineObj *result = 0 ;
18919 :
18920 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_leaderline_get",&obj0)) SWIG_fail;
18921 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18922 0 : if (!SWIG_IsOK(res1)) {
18923 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_leaderline_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18924 : }
18925 0 : arg1 = (labelCacheMemberObj *)(argp1);
18926 0 : result = (lineObj *) ((arg1)->leaderline);
18927 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, 0 | 0 );
18928 0 : return resultobj;
18929 0 : fail:
18930 : return NULL;
18931 : }
18932 :
18933 :
18934 0 : SWIGINTERN PyObject *_wrap_labelCacheMemberObj_leaderbbox_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18935 : PyObject *resultobj = 0;
18936 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18937 0 : void *argp1 = 0 ;
18938 : int res1 = 0 ;
18939 0 : PyObject * obj0 = 0 ;
18940 : rectObj *result = 0 ;
18941 :
18942 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheMemberObj_leaderbbox_get",&obj0)) SWIG_fail;
18943 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
18944 0 : if (!SWIG_IsOK(res1)) {
18945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheMemberObj_leaderbbox_get" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
18946 : }
18947 0 : arg1 = (labelCacheMemberObj *)(argp1);
18948 0 : result = (rectObj *) ((arg1)->leaderbbox);
18949 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
18950 0 : return resultobj;
18951 0 : fail:
18952 : return NULL;
18953 : }
18954 :
18955 :
18956 0 : SWIGINTERN PyObject *_wrap_new_labelCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18957 : PyObject *resultobj = 0;
18958 : labelCacheMemberObj *result = 0 ;
18959 :
18960 0 : if (!PyArg_ParseTuple(args,(char *)":new_labelCacheMemberObj")) SWIG_fail;
18961 : {
18962 0 : result = (labelCacheMemberObj *)calloc(1, sizeof(labelCacheMemberObj)); {
18963 0 : errorObj *ms_error = msGetErrorObj();
18964 :
18965 0 : switch(ms_error->code) {
18966 : case MS_NOERR:
18967 : break;
18968 0 : case MS_NOTFOUND:
18969 0 : msResetErrorList();
18970 0 : break;
18971 : case -1:
18972 : break;
18973 0 : case MS_IOERR:
18974 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
18975 0 : _raise_ms_exception();
18976 0 : msResetErrorList();
18977 0 : return NULL;
18978 : }
18979 : default:
18980 0 : _raise_ms_exception();
18981 0 : msResetErrorList();
18982 0 : return NULL;
18983 : }
18984 :
18985 : }
18986 : }
18987 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheMemberObj, SWIG_POINTER_NEW | 0 );
18988 0 : return resultobj;
18989 0 : fail:
18990 : return NULL;
18991 : }
18992 :
18993 :
18994 0 : SWIGINTERN PyObject *_wrap_delete_labelCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18995 : PyObject *resultobj = 0;
18996 : labelCacheMemberObj *arg1 = (labelCacheMemberObj *) 0 ;
18997 0 : void *argp1 = 0 ;
18998 : int res1 = 0 ;
18999 0 : PyObject * obj0 = 0 ;
19000 :
19001 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheMemberObj",&obj0)) SWIG_fail;
19002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheMemberObj, SWIG_POINTER_DISOWN | 0 );
19003 0 : if (!SWIG_IsOK(res1)) {
19004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheMemberObj" "', argument " "1"" of type '" "labelCacheMemberObj *""'");
19005 : }
19006 0 : arg1 = (labelCacheMemberObj *)(argp1);
19007 : {
19008 0 : free((char *) arg1); {
19009 0 : errorObj *ms_error = msGetErrorObj();
19010 :
19011 0 : switch(ms_error->code) {
19012 : case MS_NOERR:
19013 : break;
19014 0 : case MS_NOTFOUND:
19015 0 : msResetErrorList();
19016 0 : break;
19017 : case -1:
19018 : break;
19019 0 : case MS_IOERR:
19020 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19021 0 : _raise_ms_exception();
19022 0 : msResetErrorList();
19023 0 : return NULL;
19024 : }
19025 : default:
19026 0 : _raise_ms_exception();
19027 0 : msResetErrorList();
19028 0 : return NULL;
19029 : }
19030 :
19031 : }
19032 : }
19033 : resultobj = SWIG_Py_Void();
19034 0 : return resultobj;
19035 0 : fail:
19036 : return NULL;
19037 : }
19038 :
19039 :
19040 1 : SWIGINTERN PyObject *labelCacheMemberObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19041 : PyObject *obj;
19042 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
19043 1 : SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheMemberObj, SWIG_NewClientData(obj));
19044 1 : return SWIG_Py_Void();
19045 : }
19046 :
19047 0 : SWIGINTERN PyObject *_wrap_markerCacheMemberObj_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19048 : PyObject *resultobj = 0;
19049 : markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
19050 0 : void *argp1 = 0 ;
19051 : int res1 = 0 ;
19052 0 : PyObject * obj0 = 0 ;
19053 : int result;
19054 :
19055 0 : if (!PyArg_ParseTuple(args,(char *)"O:markerCacheMemberObj_id_get",&obj0)) SWIG_fail;
19056 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, 0 | 0 );
19057 0 : if (!SWIG_IsOK(res1)) {
19058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "markerCacheMemberObj_id_get" "', argument " "1"" of type '" "markerCacheMemberObj *""'");
19059 : }
19060 0 : arg1 = (markerCacheMemberObj *)(argp1);
19061 0 : result = (int) ((arg1)->id);
19062 : resultobj = SWIG_From_int((int)(result));
19063 0 : return resultobj;
19064 0 : fail:
19065 : return NULL;
19066 : }
19067 :
19068 :
19069 0 : SWIGINTERN PyObject *_wrap_markerCacheMemberObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19070 : PyObject *resultobj = 0;
19071 : markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
19072 0 : void *argp1 = 0 ;
19073 : int res1 = 0 ;
19074 0 : PyObject * obj0 = 0 ;
19075 : rectObj *result = 0 ;
19076 :
19077 0 : if (!PyArg_ParseTuple(args,(char *)"O:markerCacheMemberObj_bounds_get",&obj0)) SWIG_fail;
19078 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, 0 | 0 );
19079 0 : if (!SWIG_IsOK(res1)) {
19080 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "markerCacheMemberObj_bounds_get" "', argument " "1"" of type '" "markerCacheMemberObj *""'");
19081 : }
19082 0 : arg1 = (markerCacheMemberObj *)(argp1);
19083 0 : result = (rectObj *)& ((arg1)->bounds);
19084 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
19085 0 : return resultobj;
19086 0 : fail:
19087 : return NULL;
19088 : }
19089 :
19090 :
19091 0 : SWIGINTERN PyObject *_wrap_new_markerCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19092 : PyObject *resultobj = 0;
19093 : markerCacheMemberObj *result = 0 ;
19094 :
19095 0 : if (!PyArg_ParseTuple(args,(char *)":new_markerCacheMemberObj")) SWIG_fail;
19096 : {
19097 0 : result = (markerCacheMemberObj *)calloc(1, sizeof(markerCacheMemberObj)); {
19098 0 : errorObj *ms_error = msGetErrorObj();
19099 :
19100 0 : switch(ms_error->code) {
19101 : case MS_NOERR:
19102 : break;
19103 0 : case MS_NOTFOUND:
19104 0 : msResetErrorList();
19105 0 : break;
19106 : case -1:
19107 : break;
19108 0 : case MS_IOERR:
19109 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19110 0 : _raise_ms_exception();
19111 0 : msResetErrorList();
19112 0 : return NULL;
19113 : }
19114 : default:
19115 0 : _raise_ms_exception();
19116 0 : msResetErrorList();
19117 0 : return NULL;
19118 : }
19119 :
19120 : }
19121 : }
19122 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_markerCacheMemberObj, SWIG_POINTER_NEW | 0 );
19123 0 : return resultobj;
19124 0 : fail:
19125 : return NULL;
19126 : }
19127 :
19128 :
19129 0 : SWIGINTERN PyObject *_wrap_delete_markerCacheMemberObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19130 : PyObject *resultobj = 0;
19131 : markerCacheMemberObj *arg1 = (markerCacheMemberObj *) 0 ;
19132 0 : void *argp1 = 0 ;
19133 : int res1 = 0 ;
19134 0 : PyObject * obj0 = 0 ;
19135 :
19136 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_markerCacheMemberObj",&obj0)) SWIG_fail;
19137 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_markerCacheMemberObj, SWIG_POINTER_DISOWN | 0 );
19138 0 : if (!SWIG_IsOK(res1)) {
19139 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_markerCacheMemberObj" "', argument " "1"" of type '" "markerCacheMemberObj *""'");
19140 : }
19141 0 : arg1 = (markerCacheMemberObj *)(argp1);
19142 : {
19143 0 : free((char *) arg1); {
19144 0 : errorObj *ms_error = msGetErrorObj();
19145 :
19146 0 : switch(ms_error->code) {
19147 : case MS_NOERR:
19148 : break;
19149 0 : case MS_NOTFOUND:
19150 0 : msResetErrorList();
19151 0 : break;
19152 : case -1:
19153 : break;
19154 0 : case MS_IOERR:
19155 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19156 0 : _raise_ms_exception();
19157 0 : msResetErrorList();
19158 0 : return NULL;
19159 : }
19160 : default:
19161 0 : _raise_ms_exception();
19162 0 : msResetErrorList();
19163 0 : return NULL;
19164 : }
19165 :
19166 : }
19167 : }
19168 : resultobj = SWIG_Py_Void();
19169 0 : return resultobj;
19170 0 : fail:
19171 : return NULL;
19172 : }
19173 :
19174 :
19175 1 : SWIGINTERN PyObject *markerCacheMemberObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19176 : PyObject *obj;
19177 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
19178 1 : SWIG_TypeNewClientData(SWIGTYPE_p_markerCacheMemberObj, SWIG_NewClientData(obj));
19179 1 : return SWIG_Py_Void();
19180 : }
19181 :
19182 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_labels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19183 : PyObject *resultobj = 0;
19184 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19185 0 : void *argp1 = 0 ;
19186 : int res1 = 0 ;
19187 0 : PyObject * obj0 = 0 ;
19188 : labelCacheMemberObj *result = 0 ;
19189 :
19190 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_labels_get",&obj0)) SWIG_fail;
19191 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19192 0 : if (!SWIG_IsOK(res1)) {
19193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_labels_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19194 : }
19195 0 : arg1 = (labelCacheSlotObj *)(argp1);
19196 0 : result = (labelCacheMemberObj *) ((arg1)->labels);
19197 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheMemberObj, 0 | 0 );
19198 0 : return resultobj;
19199 0 : fail:
19200 : return NULL;
19201 : }
19202 :
19203 :
19204 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_numlabels_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19205 : PyObject *resultobj = 0;
19206 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19207 0 : void *argp1 = 0 ;
19208 : int res1 = 0 ;
19209 0 : PyObject * obj0 = 0 ;
19210 : int result;
19211 :
19212 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_numlabels_get",&obj0)) SWIG_fail;
19213 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19214 0 : if (!SWIG_IsOK(res1)) {
19215 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_numlabels_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19216 : }
19217 0 : arg1 = (labelCacheSlotObj *)(argp1);
19218 0 : result = (int) ((arg1)->numlabels);
19219 : resultobj = SWIG_From_int((int)(result));
19220 0 : return resultobj;
19221 0 : fail:
19222 : return NULL;
19223 : }
19224 :
19225 :
19226 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_cachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19227 : PyObject *resultobj = 0;
19228 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19229 0 : void *argp1 = 0 ;
19230 : int res1 = 0 ;
19231 0 : PyObject * obj0 = 0 ;
19232 : int result;
19233 :
19234 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_cachesize_get",&obj0)) SWIG_fail;
19235 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19236 0 : if (!SWIG_IsOK(res1)) {
19237 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_cachesize_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19238 : }
19239 0 : arg1 = (labelCacheSlotObj *)(argp1);
19240 0 : result = (int) ((arg1)->cachesize);
19241 : resultobj = SWIG_From_int((int)(result));
19242 0 : return resultobj;
19243 0 : fail:
19244 : return NULL;
19245 : }
19246 :
19247 :
19248 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_markers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19249 : PyObject *resultobj = 0;
19250 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19251 0 : void *argp1 = 0 ;
19252 : int res1 = 0 ;
19253 0 : PyObject * obj0 = 0 ;
19254 : markerCacheMemberObj *result = 0 ;
19255 :
19256 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_markers_get",&obj0)) SWIG_fail;
19257 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19258 0 : if (!SWIG_IsOK(res1)) {
19259 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_markers_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19260 : }
19261 0 : arg1 = (labelCacheSlotObj *)(argp1);
19262 0 : result = (markerCacheMemberObj *) ((arg1)->markers);
19263 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_markerCacheMemberObj, 0 | 0 );
19264 0 : return resultobj;
19265 0 : fail:
19266 : return NULL;
19267 : }
19268 :
19269 :
19270 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_nummarkers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19271 : PyObject *resultobj = 0;
19272 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19273 0 : void *argp1 = 0 ;
19274 : int res1 = 0 ;
19275 0 : PyObject * obj0 = 0 ;
19276 : int result;
19277 :
19278 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_nummarkers_get",&obj0)) SWIG_fail;
19279 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19280 0 : if (!SWIG_IsOK(res1)) {
19281 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_nummarkers_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19282 : }
19283 0 : arg1 = (labelCacheSlotObj *)(argp1);
19284 0 : result = (int) ((arg1)->nummarkers);
19285 : resultobj = SWIG_From_int((int)(result));
19286 0 : return resultobj;
19287 0 : fail:
19288 : return NULL;
19289 : }
19290 :
19291 :
19292 0 : SWIGINTERN PyObject *_wrap_labelCacheSlotObj_markercachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19293 : PyObject *resultobj = 0;
19294 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19295 0 : void *argp1 = 0 ;
19296 : int res1 = 0 ;
19297 0 : PyObject * obj0 = 0 ;
19298 : int result;
19299 :
19300 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheSlotObj_markercachesize_get",&obj0)) SWIG_fail;
19301 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19302 0 : if (!SWIG_IsOK(res1)) {
19303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheSlotObj_markercachesize_get" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19304 : }
19305 0 : arg1 = (labelCacheSlotObj *)(argp1);
19306 0 : result = (int) ((arg1)->markercachesize);
19307 : resultobj = SWIG_From_int((int)(result));
19308 0 : return resultobj;
19309 0 : fail:
19310 : return NULL;
19311 : }
19312 :
19313 :
19314 0 : SWIGINTERN PyObject *_wrap_new_labelCacheSlotObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19315 : PyObject *resultobj = 0;
19316 : labelCacheSlotObj *result = 0 ;
19317 :
19318 0 : if (!PyArg_ParseTuple(args,(char *)":new_labelCacheSlotObj")) SWIG_fail;
19319 : {
19320 0 : result = (labelCacheSlotObj *)calloc(1, sizeof(labelCacheSlotObj)); {
19321 0 : errorObj *ms_error = msGetErrorObj();
19322 :
19323 0 : switch(ms_error->code) {
19324 : case MS_NOERR:
19325 : break;
19326 0 : case MS_NOTFOUND:
19327 0 : msResetErrorList();
19328 0 : break;
19329 : case -1:
19330 : break;
19331 0 : case MS_IOERR:
19332 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19333 0 : _raise_ms_exception();
19334 0 : msResetErrorList();
19335 0 : return NULL;
19336 : }
19337 : default:
19338 0 : _raise_ms_exception();
19339 0 : msResetErrorList();
19340 0 : return NULL;
19341 : }
19342 :
19343 : }
19344 : }
19345 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheSlotObj, SWIG_POINTER_NEW | 0 );
19346 0 : return resultobj;
19347 0 : fail:
19348 : return NULL;
19349 : }
19350 :
19351 :
19352 0 : SWIGINTERN PyObject *_wrap_delete_labelCacheSlotObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19353 : PyObject *resultobj = 0;
19354 : labelCacheSlotObj *arg1 = (labelCacheSlotObj *) 0 ;
19355 0 : void *argp1 = 0 ;
19356 : int res1 = 0 ;
19357 0 : PyObject * obj0 = 0 ;
19358 :
19359 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheSlotObj",&obj0)) SWIG_fail;
19360 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheSlotObj, SWIG_POINTER_DISOWN | 0 );
19361 0 : if (!SWIG_IsOK(res1)) {
19362 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheSlotObj" "', argument " "1"" of type '" "labelCacheSlotObj *""'");
19363 : }
19364 0 : arg1 = (labelCacheSlotObj *)(argp1);
19365 : {
19366 0 : free((char *) arg1); {
19367 0 : errorObj *ms_error = msGetErrorObj();
19368 :
19369 0 : switch(ms_error->code) {
19370 : case MS_NOERR:
19371 : break;
19372 0 : case MS_NOTFOUND:
19373 0 : msResetErrorList();
19374 0 : break;
19375 : case -1:
19376 : break;
19377 0 : case MS_IOERR:
19378 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19379 0 : _raise_ms_exception();
19380 0 : msResetErrorList();
19381 0 : return NULL;
19382 : }
19383 : default:
19384 0 : _raise_ms_exception();
19385 0 : msResetErrorList();
19386 0 : return NULL;
19387 : }
19388 :
19389 : }
19390 : }
19391 : resultobj = SWIG_Py_Void();
19392 0 : return resultobj;
19393 0 : fail:
19394 : return NULL;
19395 : }
19396 :
19397 :
19398 1 : SWIGINTERN PyObject *labelCacheSlotObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 : PyObject *obj;
19400 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
19401 1 : SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheSlotObj, SWIG_NewClientData(obj));
19402 1 : return SWIG_Py_Void();
19403 : }
19404 :
19405 0 : SWIGINTERN PyObject *_wrap_labelCacheObj_slots_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19406 : PyObject *resultobj = 0;
19407 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19408 0 : void *argp1 = 0 ;
19409 : int res1 = 0 ;
19410 0 : PyObject * obj0 = 0 ;
19411 : labelCacheSlotObj *result = 0 ;
19412 :
19413 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_slots_get",&obj0)) SWIG_fail;
19414 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19415 0 : if (!SWIG_IsOK(res1)) {
19416 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_slots_get" "', argument " "1"" of type '" "labelCacheObj *""'");
19417 : }
19418 0 : arg1 = (labelCacheObj *)(argp1);
19419 0 : result = (labelCacheSlotObj *)(labelCacheSlotObj *) ((arg1)->slots);
19420 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheSlotObj, 0 | 0 );
19421 0 : return resultobj;
19422 0 : fail:
19423 : return NULL;
19424 : }
19425 :
19426 :
19427 0 : SWIGINTERN PyObject *_wrap_labelCacheObj_gutter_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19428 : PyObject *resultobj = 0;
19429 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19430 0 : void *argp1 = 0 ;
19431 : int res1 = 0 ;
19432 0 : PyObject * obj0 = 0 ;
19433 : int result;
19434 :
19435 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_gutter_get",&obj0)) SWIG_fail;
19436 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19437 0 : if (!SWIG_IsOK(res1)) {
19438 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_gutter_get" "', argument " "1"" of type '" "labelCacheObj *""'");
19439 : }
19440 0 : arg1 = (labelCacheObj *)(argp1);
19441 0 : result = (int) ((arg1)->gutter);
19442 : resultobj = SWIG_From_int((int)(result));
19443 0 : return resultobj;
19444 0 : fail:
19445 : return NULL;
19446 : }
19447 :
19448 :
19449 0 : SWIGINTERN PyObject *_wrap_labelCacheObj_rendered_text_symbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19450 : PyObject *resultobj = 0;
19451 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19452 0 : void *argp1 = 0 ;
19453 : int res1 = 0 ;
19454 0 : PyObject * obj0 = 0 ;
19455 : labelCacheMemberObj **result = 0 ;
19456 :
19457 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_rendered_text_symbols_get",&obj0)) SWIG_fail;
19458 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19459 0 : if (!SWIG_IsOK(res1)) {
19460 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_rendered_text_symbols_get" "', argument " "1"" of type '" "labelCacheObj *""'");
19461 : }
19462 0 : arg1 = (labelCacheObj *)(argp1);
19463 0 : result = (labelCacheMemberObj **) ((arg1)->rendered_text_symbols);
19464 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_labelCacheMemberObj, 0 | 0 );
19465 0 : return resultobj;
19466 0 : fail:
19467 : return NULL;
19468 : }
19469 :
19470 :
19471 0 : SWIGINTERN PyObject *_wrap_labelCacheObj_num_allocated_rendered_members_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19472 : PyObject *resultobj = 0;
19473 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19474 0 : void *argp1 = 0 ;
19475 : int res1 = 0 ;
19476 0 : PyObject * obj0 = 0 ;
19477 : int result;
19478 :
19479 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_num_allocated_rendered_members_get",&obj0)) SWIG_fail;
19480 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19481 0 : if (!SWIG_IsOK(res1)) {
19482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_num_allocated_rendered_members_get" "', argument " "1"" of type '" "labelCacheObj *""'");
19483 : }
19484 0 : arg1 = (labelCacheObj *)(argp1);
19485 0 : result = (int) ((arg1)->num_allocated_rendered_members);
19486 : resultobj = SWIG_From_int((int)(result));
19487 0 : return resultobj;
19488 0 : fail:
19489 : return NULL;
19490 : }
19491 :
19492 :
19493 1 : SWIGINTERN PyObject *_wrap_labelCacheObj_num_rendered_members_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19494 : PyObject *resultobj = 0;
19495 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19496 1 : void *argp1 = 0 ;
19497 : int res1 = 0 ;
19498 1 : PyObject * obj0 = 0 ;
19499 : int result;
19500 :
19501 1 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_num_rendered_members_get",&obj0)) SWIG_fail;
19502 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19503 1 : if (!SWIG_IsOK(res1)) {
19504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_num_rendered_members_get" "', argument " "1"" of type '" "labelCacheObj *""'");
19505 : }
19506 1 : arg1 = (labelCacheObj *)(argp1);
19507 1 : result = (int) ((arg1)->num_rendered_members);
19508 : resultobj = SWIG_From_int((int)(result));
19509 1 : return resultobj;
19510 0 : fail:
19511 : return NULL;
19512 : }
19513 :
19514 :
19515 0 : SWIGINTERN PyObject *_wrap_labelCacheObj_freeCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19516 : PyObject *resultobj = 0;
19517 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19518 0 : void *argp1 = 0 ;
19519 : int res1 = 0 ;
19520 0 : PyObject * obj0 = 0 ;
19521 :
19522 0 : if (!PyArg_ParseTuple(args,(char *)"O:labelCacheObj_freeCache",&obj0)) SWIG_fail;
19523 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, 0 | 0 );
19524 0 : if (!SWIG_IsOK(res1)) {
19525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "labelCacheObj_freeCache" "', argument " "1"" of type '" "labelCacheObj *""'");
19526 : }
19527 0 : arg1 = (labelCacheObj *)(argp1);
19528 : {
19529 : labelCacheObj_freeCache(arg1); {
19530 0 : errorObj *ms_error = msGetErrorObj();
19531 :
19532 0 : switch(ms_error->code) {
19533 : case MS_NOERR:
19534 : break;
19535 0 : case MS_NOTFOUND:
19536 0 : msResetErrorList();
19537 0 : break;
19538 : case -1:
19539 : break;
19540 0 : case MS_IOERR:
19541 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19542 0 : _raise_ms_exception();
19543 0 : msResetErrorList();
19544 0 : return NULL;
19545 : }
19546 : default:
19547 0 : _raise_ms_exception();
19548 0 : msResetErrorList();
19549 0 : return NULL;
19550 : }
19551 :
19552 : }
19553 : }
19554 : resultobj = SWIG_Py_Void();
19555 0 : return resultobj;
19556 0 : fail:
19557 : return NULL;
19558 : }
19559 :
19560 :
19561 0 : SWIGINTERN PyObject *_wrap_new_labelCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19562 : PyObject *resultobj = 0;
19563 : labelCacheObj *result = 0 ;
19564 :
19565 0 : if (!PyArg_ParseTuple(args,(char *)":new_labelCacheObj")) SWIG_fail;
19566 : {
19567 0 : result = (labelCacheObj *)calloc(1, sizeof(labelCacheObj)); {
19568 0 : errorObj *ms_error = msGetErrorObj();
19569 :
19570 0 : switch(ms_error->code) {
19571 : case MS_NOERR:
19572 : break;
19573 0 : case MS_NOTFOUND:
19574 0 : msResetErrorList();
19575 0 : break;
19576 : case -1:
19577 : break;
19578 0 : case MS_IOERR:
19579 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19580 0 : _raise_ms_exception();
19581 0 : msResetErrorList();
19582 0 : return NULL;
19583 : }
19584 : default:
19585 0 : _raise_ms_exception();
19586 0 : msResetErrorList();
19587 0 : return NULL;
19588 : }
19589 :
19590 : }
19591 : }
19592 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheObj, SWIG_POINTER_NEW | 0 );
19593 0 : return resultobj;
19594 0 : fail:
19595 : return NULL;
19596 : }
19597 :
19598 :
19599 0 : SWIGINTERN PyObject *_wrap_delete_labelCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19600 : PyObject *resultobj = 0;
19601 : labelCacheObj *arg1 = (labelCacheObj *) 0 ;
19602 0 : void *argp1 = 0 ;
19603 : int res1 = 0 ;
19604 0 : PyObject * obj0 = 0 ;
19605 :
19606 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_labelCacheObj",&obj0)) SWIG_fail;
19607 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_labelCacheObj, SWIG_POINTER_DISOWN | 0 );
19608 0 : if (!SWIG_IsOK(res1)) {
19609 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_labelCacheObj" "', argument " "1"" of type '" "labelCacheObj *""'");
19610 : }
19611 0 : arg1 = (labelCacheObj *)(argp1);
19612 : {
19613 0 : free((char *) arg1); {
19614 0 : errorObj *ms_error = msGetErrorObj();
19615 :
19616 0 : switch(ms_error->code) {
19617 : case MS_NOERR:
19618 : break;
19619 0 : case MS_NOTFOUND:
19620 0 : msResetErrorList();
19621 0 : break;
19622 : case -1:
19623 : break;
19624 0 : case MS_IOERR:
19625 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19626 0 : _raise_ms_exception();
19627 0 : msResetErrorList();
19628 0 : return NULL;
19629 : }
19630 : default:
19631 0 : _raise_ms_exception();
19632 0 : msResetErrorList();
19633 0 : return NULL;
19634 : }
19635 :
19636 : }
19637 : }
19638 : resultobj = SWIG_Py_Void();
19639 0 : return resultobj;
19640 0 : fail:
19641 : return NULL;
19642 : }
19643 :
19644 :
19645 1 : SWIGINTERN PyObject *labelCacheObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19646 : PyObject *obj;
19647 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
19648 1 : SWIG_TypeNewClientData(SWIGTYPE_p_labelCacheObj, SWIG_NewClientData(obj));
19649 1 : return SWIG_Py_Void();
19650 : }
19651 :
19652 1 : SWIGINTERN PyObject *_wrap_resultObj_shapeindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19653 : PyObject *resultobj = 0;
19654 : resultObj *arg1 = (resultObj *) 0 ;
19655 1 : void *argp1 = 0 ;
19656 : int res1 = 0 ;
19657 1 : PyObject * obj0 = 0 ;
19658 : long result;
19659 :
19660 1 : if (!PyArg_ParseTuple(args,(char *)"O:resultObj_shapeindex_get",&obj0)) SWIG_fail;
19661 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 | 0 );
19662 1 : if (!SWIG_IsOK(res1)) {
19663 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_shapeindex_get" "', argument " "1"" of type '" "resultObj *""'");
19664 : }
19665 1 : arg1 = (resultObj *)(argp1);
19666 1 : result = (long) ((arg1)->shapeindex);
19667 1 : resultobj = SWIG_From_long((long)(result));
19668 1 : return resultobj;
19669 0 : fail:
19670 : return NULL;
19671 : }
19672 :
19673 :
19674 0 : SWIGINTERN PyObject *_wrap_resultObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19675 : PyObject *resultobj = 0;
19676 : resultObj *arg1 = (resultObj *) 0 ;
19677 0 : void *argp1 = 0 ;
19678 : int res1 = 0 ;
19679 0 : PyObject * obj0 = 0 ;
19680 : int result;
19681 :
19682 0 : if (!PyArg_ParseTuple(args,(char *)"O:resultObj_tileindex_get",&obj0)) SWIG_fail;
19683 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 | 0 );
19684 0 : if (!SWIG_IsOK(res1)) {
19685 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_tileindex_get" "', argument " "1"" of type '" "resultObj *""'");
19686 : }
19687 0 : arg1 = (resultObj *)(argp1);
19688 0 : result = (int) ((arg1)->tileindex);
19689 : resultobj = SWIG_From_int((int)(result));
19690 0 : return resultobj;
19691 0 : fail:
19692 : return NULL;
19693 : }
19694 :
19695 :
19696 0 : SWIGINTERN PyObject *_wrap_resultObj_resultindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19697 : PyObject *resultobj = 0;
19698 : resultObj *arg1 = (resultObj *) 0 ;
19699 0 : void *argp1 = 0 ;
19700 : int res1 = 0 ;
19701 0 : PyObject * obj0 = 0 ;
19702 : int result;
19703 :
19704 0 : if (!PyArg_ParseTuple(args,(char *)"O:resultObj_resultindex_get",&obj0)) SWIG_fail;
19705 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 | 0 );
19706 0 : if (!SWIG_IsOK(res1)) {
19707 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_resultindex_get" "', argument " "1"" of type '" "resultObj *""'");
19708 : }
19709 0 : arg1 = (resultObj *)(argp1);
19710 0 : result = (int) ((arg1)->resultindex);
19711 : resultobj = SWIG_From_int((int)(result));
19712 0 : return resultobj;
19713 0 : fail:
19714 : return NULL;
19715 : }
19716 :
19717 :
19718 0 : SWIGINTERN PyObject *_wrap_resultObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19719 : PyObject *resultobj = 0;
19720 : resultObj *arg1 = (resultObj *) 0 ;
19721 0 : void *argp1 = 0 ;
19722 : int res1 = 0 ;
19723 0 : PyObject * obj0 = 0 ;
19724 : int result;
19725 :
19726 0 : if (!PyArg_ParseTuple(args,(char *)"O:resultObj_classindex_get",&obj0)) SWIG_fail;
19727 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, 0 | 0 );
19728 0 : if (!SWIG_IsOK(res1)) {
19729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultObj_classindex_get" "', argument " "1"" of type '" "resultObj *""'");
19730 : }
19731 0 : arg1 = (resultObj *)(argp1);
19732 0 : result = (int) ((arg1)->classindex);
19733 : resultobj = SWIG_From_int((int)(result));
19734 0 : return resultobj;
19735 0 : fail:
19736 : return NULL;
19737 : }
19738 :
19739 :
19740 0 : SWIGINTERN PyObject *_wrap_new_resultObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 : PyObject *resultobj = 0;
19742 : long arg1 ;
19743 : long val1 ;
19744 : int ecode1 = 0 ;
19745 0 : PyObject * obj0 = 0 ;
19746 : resultObj *result = 0 ;
19747 :
19748 0 : if (!PyArg_ParseTuple(args,(char *)"O:new_resultObj",&obj0)) SWIG_fail;
19749 0 : ecode1 = SWIG_AsVal_long(obj0, &val1);
19750 0 : if (!SWIG_IsOK(ecode1)) {
19751 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_resultObj" "', argument " "1"" of type '" "long""'");
19752 : }
19753 0 : arg1 = (long)(val1);
19754 : {
19755 : result = (resultObj *)new_resultObj(arg1); {
19756 0 : errorObj *ms_error = msGetErrorObj();
19757 :
19758 0 : switch(ms_error->code) {
19759 : case MS_NOERR:
19760 : break;
19761 0 : case MS_NOTFOUND:
19762 0 : msResetErrorList();
19763 0 : break;
19764 : case -1:
19765 : break;
19766 0 : case MS_IOERR:
19767 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19768 0 : _raise_ms_exception();
19769 0 : msResetErrorList();
19770 0 : return NULL;
19771 : }
19772 : default:
19773 0 : _raise_ms_exception();
19774 0 : msResetErrorList();
19775 0 : return NULL;
19776 : }
19777 :
19778 : }
19779 : }
19780 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, SWIG_POINTER_NEW | 0 );
19781 0 : return resultobj;
19782 0 : fail:
19783 : return NULL;
19784 : }
19785 :
19786 :
19787 0 : SWIGINTERN PyObject *_wrap_delete_resultObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19788 : PyObject *resultobj = 0;
19789 : resultObj *arg1 = (resultObj *) 0 ;
19790 0 : void *argp1 = 0 ;
19791 : int res1 = 0 ;
19792 0 : PyObject * obj0 = 0 ;
19793 :
19794 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_resultObj",&obj0)) SWIG_fail;
19795 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultObj, SWIG_POINTER_DISOWN | 0 );
19796 0 : if (!SWIG_IsOK(res1)) {
19797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_resultObj" "', argument " "1"" of type '" "resultObj *""'");
19798 : }
19799 0 : arg1 = (resultObj *)(argp1);
19800 : {
19801 : delete_resultObj(arg1); {
19802 0 : errorObj *ms_error = msGetErrorObj();
19803 :
19804 0 : switch(ms_error->code) {
19805 : case MS_NOERR:
19806 : break;
19807 0 : case MS_NOTFOUND:
19808 0 : msResetErrorList();
19809 0 : break;
19810 : case -1:
19811 : break;
19812 0 : case MS_IOERR:
19813 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19814 0 : _raise_ms_exception();
19815 0 : msResetErrorList();
19816 0 : return NULL;
19817 : }
19818 : default:
19819 0 : _raise_ms_exception();
19820 0 : msResetErrorList();
19821 0 : return NULL;
19822 : }
19823 :
19824 : }
19825 : }
19826 : resultobj = SWIG_Py_Void();
19827 0 : return resultobj;
19828 0 : fail:
19829 : return NULL;
19830 : }
19831 :
19832 :
19833 1 : SWIGINTERN PyObject *resultObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19834 : PyObject *obj;
19835 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
19836 1 : SWIG_TypeNewClientData(SWIGTYPE_p_resultObj, SWIG_NewClientData(obj));
19837 1 : return SWIG_Py_Void();
19838 : }
19839 :
19840 1 : SWIGINTERN PyObject *_wrap_resultCacheObj_numresults_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19841 : PyObject *resultobj = 0;
19842 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
19843 1 : void *argp1 = 0 ;
19844 : int res1 = 0 ;
19845 1 : PyObject * obj0 = 0 ;
19846 : int result;
19847 :
19848 1 : if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_numresults_get",&obj0)) SWIG_fail;
19849 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 | 0 );
19850 1 : if (!SWIG_IsOK(res1)) {
19851 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_numresults_get" "', argument " "1"" of type '" "resultCacheObj *""'");
19852 : }
19853 1 : arg1 = (resultCacheObj *)(argp1);
19854 1 : result = (int) ((arg1)->numresults);
19855 : resultobj = SWIG_From_int((int)(result));
19856 1 : return resultobj;
19857 0 : fail:
19858 : return NULL;
19859 : }
19860 :
19861 :
19862 1 : SWIGINTERN PyObject *_wrap_resultCacheObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19863 : PyObject *resultobj = 0;
19864 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
19865 1 : void *argp1 = 0 ;
19866 : int res1 = 0 ;
19867 1 : PyObject * obj0 = 0 ;
19868 : rectObj *result = 0 ;
19869 :
19870 1 : if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_bounds_get",&obj0)) SWIG_fail;
19871 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 | 0 );
19872 1 : if (!SWIG_IsOK(res1)) {
19873 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_bounds_get" "', argument " "1"" of type '" "resultCacheObj *""'");
19874 : }
19875 1 : arg1 = (resultCacheObj *)(argp1);
19876 1 : result = (rectObj *)& ((arg1)->bounds);
19877 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
19878 1 : return resultobj;
19879 0 : fail:
19880 : return NULL;
19881 : }
19882 :
19883 :
19884 0 : SWIGINTERN PyObject *_wrap_resultCacheObj_usegetshape_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 : PyObject *resultobj = 0;
19886 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
19887 : int arg2 ;
19888 0 : void *argp1 = 0 ;
19889 : int res1 = 0 ;
19890 : int val2 ;
19891 : int ecode2 = 0 ;
19892 0 : PyObject * obj0 = 0 ;
19893 0 : PyObject * obj1 = 0 ;
19894 :
19895 0 : if (!PyArg_ParseTuple(args,(char *)"OO:resultCacheObj_usegetshape_set",&obj0,&obj1)) SWIG_fail;
19896 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 | 0 );
19897 0 : if (!SWIG_IsOK(res1)) {
19898 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_usegetshape_set" "', argument " "1"" of type '" "resultCacheObj *""'");
19899 : }
19900 0 : arg1 = (resultCacheObj *)(argp1);
19901 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19902 0 : if (!SWIG_IsOK(ecode2)) {
19903 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "resultCacheObj_usegetshape_set" "', argument " "2"" of type '" "int""'");
19904 : }
19905 : arg2 = (int)(val2);
19906 0 : if (arg1) (arg1)->usegetshape = arg2;
19907 : resultobj = SWIG_Py_Void();
19908 0 : return resultobj;
19909 0 : fail:
19910 : return NULL;
19911 : }
19912 :
19913 :
19914 0 : SWIGINTERN PyObject *_wrap_resultCacheObj_usegetshape_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19915 : PyObject *resultobj = 0;
19916 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
19917 0 : void *argp1 = 0 ;
19918 : int res1 = 0 ;
19919 0 : PyObject * obj0 = 0 ;
19920 : int result;
19921 :
19922 0 : if (!PyArg_ParseTuple(args,(char *)"O:resultCacheObj_usegetshape_get",&obj0)) SWIG_fail;
19923 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 | 0 );
19924 0 : if (!SWIG_IsOK(res1)) {
19925 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_usegetshape_get" "', argument " "1"" of type '" "resultCacheObj *""'");
19926 : }
19927 0 : arg1 = (resultCacheObj *)(argp1);
19928 0 : result = (int) ((arg1)->usegetshape);
19929 : resultobj = SWIG_From_int((int)(result));
19930 0 : return resultobj;
19931 0 : fail:
19932 : return NULL;
19933 : }
19934 :
19935 :
19936 1 : SWIGINTERN PyObject *_wrap_resultCacheObj_getResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19937 : PyObject *resultobj = 0;
19938 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
19939 : int arg2 ;
19940 1 : void *argp1 = 0 ;
19941 : int res1 = 0 ;
19942 : int val2 ;
19943 : int ecode2 = 0 ;
19944 1 : PyObject * obj0 = 0 ;
19945 1 : PyObject * obj1 = 0 ;
19946 : resultObj *result = 0 ;
19947 :
19948 1 : if (!PyArg_ParseTuple(args,(char *)"OO:resultCacheObj_getResult",&obj0,&obj1)) SWIG_fail;
19949 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, 0 | 0 );
19950 1 : if (!SWIG_IsOK(res1)) {
19951 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "resultCacheObj_getResult" "', argument " "1"" of type '" "resultCacheObj *""'");
19952 : }
19953 1 : arg1 = (resultCacheObj *)(argp1);
19954 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19955 1 : if (!SWIG_IsOK(ecode2)) {
19956 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "resultCacheObj_getResult" "', argument " "2"" of type '" "int""'");
19957 : }
19958 : arg2 = (int)(val2);
19959 : {
19960 : result = (resultObj *)resultCacheObj_getResult(arg1,arg2); {
19961 1 : errorObj *ms_error = msGetErrorObj();
19962 :
19963 1 : switch(ms_error->code) {
19964 : case MS_NOERR:
19965 : break;
19966 0 : case MS_NOTFOUND:
19967 0 : msResetErrorList();
19968 0 : break;
19969 : case -1:
19970 : break;
19971 0 : case MS_IOERR:
19972 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
19973 0 : _raise_ms_exception();
19974 0 : msResetErrorList();
19975 0 : return NULL;
19976 : }
19977 : default:
19978 0 : _raise_ms_exception();
19979 0 : msResetErrorList();
19980 0 : return NULL;
19981 : }
19982 :
19983 : }
19984 : }
19985 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, 0 | 0 );
19986 1 : return resultobj;
19987 0 : fail:
19988 : return NULL;
19989 : }
19990 :
19991 :
19992 0 : SWIGINTERN PyObject *_wrap_new_resultCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19993 : PyObject *resultobj = 0;
19994 : resultCacheObj *result = 0 ;
19995 :
19996 0 : if (!PyArg_ParseTuple(args,(char *)":new_resultCacheObj")) SWIG_fail;
19997 : {
19998 0 : result = (resultCacheObj *)calloc(1, sizeof(resultCacheObj)); {
19999 0 : errorObj *ms_error = msGetErrorObj();
20000 :
20001 0 : switch(ms_error->code) {
20002 : case MS_NOERR:
20003 : break;
20004 0 : case MS_NOTFOUND:
20005 0 : msResetErrorList();
20006 0 : break;
20007 : case -1:
20008 : break;
20009 0 : case MS_IOERR:
20010 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20011 0 : _raise_ms_exception();
20012 0 : msResetErrorList();
20013 0 : return NULL;
20014 : }
20015 : default:
20016 0 : _raise_ms_exception();
20017 0 : msResetErrorList();
20018 0 : return NULL;
20019 : }
20020 :
20021 : }
20022 : }
20023 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultCacheObj, SWIG_POINTER_NEW | 0 );
20024 0 : return resultobj;
20025 0 : fail:
20026 : return NULL;
20027 : }
20028 :
20029 :
20030 0 : SWIGINTERN PyObject *_wrap_delete_resultCacheObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20031 : PyObject *resultobj = 0;
20032 : resultCacheObj *arg1 = (resultCacheObj *) 0 ;
20033 0 : void *argp1 = 0 ;
20034 : int res1 = 0 ;
20035 0 : PyObject * obj0 = 0 ;
20036 :
20037 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_resultCacheObj",&obj0)) SWIG_fail;
20038 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_resultCacheObj, SWIG_POINTER_DISOWN | 0 );
20039 0 : if (!SWIG_IsOK(res1)) {
20040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_resultCacheObj" "', argument " "1"" of type '" "resultCacheObj *""'");
20041 : }
20042 0 : arg1 = (resultCacheObj *)(argp1);
20043 : {
20044 0 : free((char *) arg1); {
20045 0 : errorObj *ms_error = msGetErrorObj();
20046 :
20047 0 : switch(ms_error->code) {
20048 : case MS_NOERR:
20049 : break;
20050 0 : case MS_NOTFOUND:
20051 0 : msResetErrorList();
20052 0 : break;
20053 : case -1:
20054 : break;
20055 0 : case MS_IOERR:
20056 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20057 0 : _raise_ms_exception();
20058 0 : msResetErrorList();
20059 0 : return NULL;
20060 : }
20061 : default:
20062 0 : _raise_ms_exception();
20063 0 : msResetErrorList();
20064 0 : return NULL;
20065 : }
20066 :
20067 : }
20068 : }
20069 : resultobj = SWIG_Py_Void();
20070 0 : return resultobj;
20071 0 : fail:
20072 : return NULL;
20073 : }
20074 :
20075 :
20076 1 : SWIGINTERN PyObject *resultCacheObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20077 : PyObject *obj;
20078 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
20079 1 : SWIG_TypeNewClientData(SWIGTYPE_p_resultCacheObj, SWIG_NewClientData(obj));
20080 1 : return SWIG_Py_Void();
20081 : }
20082 :
20083 0 : SWIGINTERN PyObject *_wrap_symbolSetObj_filename_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20084 : PyObject *resultobj = 0;
20085 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20086 : char *arg2 = (char *) 0 ;
20087 0 : void *argp1 = 0 ;
20088 : int res1 = 0 ;
20089 : int res2 ;
20090 0 : char *buf2 = 0 ;
20091 0 : int alloc2 = 0 ;
20092 0 : PyObject * obj0 = 0 ;
20093 0 : PyObject * obj1 = 0 ;
20094 :
20095 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_filename_set",&obj0,&obj1)) SWIG_fail;
20096 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20097 0 : if (!SWIG_IsOK(res1)) {
20098 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_filename_set" "', argument " "1"" of type '" "symbolSetObj *""'");
20099 : }
20100 0 : arg1 = (symbolSetObj *)(argp1);
20101 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20102 0 : if (!SWIG_IsOK(res2)) {
20103 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_filename_set" "', argument " "2"" of type '" "char *""'");
20104 : }
20105 0 : arg2 = (char *)(buf2);
20106 : {
20107 0 : if (arg1->filename) free((char*)arg1->filename);
20108 0 : if (arg2) {
20109 0 : arg1->filename = (char *) malloc(strlen(arg2)+1);
20110 : strcpy((char*)arg1->filename,arg2);
20111 : } else {
20112 0 : arg1->filename = 0;
20113 : }
20114 : }
20115 : resultobj = SWIG_Py_Void();
20116 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20117 : return resultobj;
20118 0 : fail:
20119 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20120 : return NULL;
20121 : }
20122 :
20123 :
20124 0 : SWIGINTERN PyObject *_wrap_symbolSetObj_filename_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20125 : PyObject *resultobj = 0;
20126 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20127 0 : void *argp1 = 0 ;
20128 : int res1 = 0 ;
20129 0 : PyObject * obj0 = 0 ;
20130 : char *result = 0 ;
20131 :
20132 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_filename_get",&obj0)) SWIG_fail;
20133 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20134 0 : if (!SWIG_IsOK(res1)) {
20135 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_filename_get" "', argument " "1"" of type '" "symbolSetObj *""'");
20136 : }
20137 0 : arg1 = (symbolSetObj *)(argp1);
20138 0 : result = (char *) ((arg1)->filename);
20139 0 : resultobj = SWIG_FromCharPtr((const char *)result);
20140 0 : return resultobj;
20141 0 : fail:
20142 : return NULL;
20143 : }
20144 :
20145 :
20146 0 : SWIGINTERN PyObject *_wrap_symbolSetObj_imagecachesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 : PyObject *resultobj = 0;
20148 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20149 : int arg2 ;
20150 0 : void *argp1 = 0 ;
20151 : int res1 = 0 ;
20152 : int val2 ;
20153 : int ecode2 = 0 ;
20154 0 : PyObject * obj0 = 0 ;
20155 0 : PyObject * obj1 = 0 ;
20156 :
20157 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_imagecachesize_set",&obj0,&obj1)) SWIG_fail;
20158 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20159 0 : if (!SWIG_IsOK(res1)) {
20160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_imagecachesize_set" "', argument " "1"" of type '" "symbolSetObj *""'");
20161 : }
20162 0 : arg1 = (symbolSetObj *)(argp1);
20163 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20164 0 : if (!SWIG_IsOK(ecode2)) {
20165 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_imagecachesize_set" "', argument " "2"" of type '" "int""'");
20166 : }
20167 : arg2 = (int)(val2);
20168 0 : if (arg1) (arg1)->imagecachesize = arg2;
20169 : resultobj = SWIG_Py_Void();
20170 0 : return resultobj;
20171 0 : fail:
20172 : return NULL;
20173 : }
20174 :
20175 :
20176 0 : SWIGINTERN PyObject *_wrap_symbolSetObj_imagecachesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20177 : PyObject *resultobj = 0;
20178 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20179 0 : void *argp1 = 0 ;
20180 : int res1 = 0 ;
20181 0 : PyObject * obj0 = 0 ;
20182 : int result;
20183 :
20184 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_imagecachesize_get",&obj0)) SWIG_fail;
20185 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20186 0 : if (!SWIG_IsOK(res1)) {
20187 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_imagecachesize_get" "', argument " "1"" of type '" "symbolSetObj *""'");
20188 : }
20189 0 : arg1 = (symbolSetObj *)(argp1);
20190 0 : result = (int) ((arg1)->imagecachesize);
20191 : resultobj = SWIG_From_int((int)(result));
20192 0 : return resultobj;
20193 0 : fail:
20194 : return NULL;
20195 : }
20196 :
20197 :
20198 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_numsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20199 : PyObject *resultobj = 0;
20200 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20201 1 : void *argp1 = 0 ;
20202 : int res1 = 0 ;
20203 1 : PyObject * obj0 = 0 ;
20204 : int result;
20205 :
20206 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_numsymbols_get",&obj0)) SWIG_fail;
20207 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20208 1 : if (!SWIG_IsOK(res1)) {
20209 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_numsymbols_get" "', argument " "1"" of type '" "symbolSetObj *""'");
20210 : }
20211 1 : arg1 = (symbolSetObj *)(argp1);
20212 1 : result = (int) ((arg1)->numsymbols);
20213 : resultobj = SWIG_From_int((int)(result));
20214 1 : return resultobj;
20215 0 : fail:
20216 : return NULL;
20217 : }
20218 :
20219 :
20220 0 : SWIGINTERN PyObject *_wrap_symbolSetObj_maxsymbols_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20221 : PyObject *resultobj = 0;
20222 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20223 0 : void *argp1 = 0 ;
20224 : int res1 = 0 ;
20225 0 : PyObject * obj0 = 0 ;
20226 : int result;
20227 :
20228 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolSetObj_maxsymbols_get",&obj0)) SWIG_fail;
20229 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20230 0 : if (!SWIG_IsOK(res1)) {
20231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_maxsymbols_get" "', argument " "1"" of type '" "symbolSetObj *""'");
20232 : }
20233 0 : arg1 = (symbolSetObj *)(argp1);
20234 0 : result = (int) ((arg1)->maxsymbols);
20235 : resultobj = SWIG_From_int((int)(result));
20236 0 : return resultobj;
20237 0 : fail:
20238 : return NULL;
20239 : }
20240 :
20241 :
20242 1 : SWIGINTERN PyObject *_wrap_new_symbolSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 : PyObject *resultobj = 0;
20244 : char *arg1 = (char *) NULL ;
20245 : int res1 ;
20246 1 : char *buf1 = 0 ;
20247 1 : int alloc1 = 0 ;
20248 1 : PyObject * obj0 = 0 ;
20249 : symbolSetObj *result = 0 ;
20250 :
20251 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_symbolSetObj",&obj0)) SWIG_fail;
20252 1 : if (obj0) {
20253 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
20254 1 : if (!SWIG_IsOK(res1)) {
20255 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_symbolSetObj" "', argument " "1"" of type '" "char const *""'");
20256 : }
20257 1 : arg1 = (char *)(buf1);
20258 : }
20259 : {
20260 1 : result = (symbolSetObj *)new_symbolSetObj((char const *)arg1); {
20261 1 : errorObj *ms_error = msGetErrorObj();
20262 :
20263 1 : switch(ms_error->code) {
20264 : case MS_NOERR:
20265 : break;
20266 0 : case MS_NOTFOUND:
20267 0 : msResetErrorList();
20268 0 : break;
20269 : case -1:
20270 : break;
20271 0 : case MS_IOERR:
20272 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20273 0 : _raise_ms_exception();
20274 0 : msResetErrorList();
20275 0 : return NULL;
20276 : }
20277 : default:
20278 0 : _raise_ms_exception();
20279 0 : msResetErrorList();
20280 0 : return NULL;
20281 : }
20282 :
20283 : }
20284 : }
20285 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolSetObj, SWIG_POINTER_NEW | 0 );
20286 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
20287 : return resultobj;
20288 0 : fail:
20289 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
20290 : return NULL;
20291 : }
20292 :
20293 :
20294 1 : SWIGINTERN PyObject *_wrap_delete_symbolSetObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 : PyObject *resultobj = 0;
20296 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20297 1 : void *argp1 = 0 ;
20298 : int res1 = 0 ;
20299 1 : PyObject * obj0 = 0 ;
20300 :
20301 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_symbolSetObj",&obj0)) SWIG_fail;
20302 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, SWIG_POINTER_DISOWN | 0 );
20303 1 : if (!SWIG_IsOK(res1)) {
20304 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_symbolSetObj" "', argument " "1"" of type '" "symbolSetObj *""'");
20305 : }
20306 1 : arg1 = (symbolSetObj *)(argp1);
20307 : {
20308 1 : delete_symbolSetObj(arg1); {
20309 1 : errorObj *ms_error = msGetErrorObj();
20310 :
20311 1 : switch(ms_error->code) {
20312 : case MS_NOERR:
20313 : break;
20314 0 : case MS_NOTFOUND:
20315 0 : msResetErrorList();
20316 0 : break;
20317 : case -1:
20318 : break;
20319 0 : case MS_IOERR:
20320 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20321 0 : _raise_ms_exception();
20322 0 : msResetErrorList();
20323 0 : return NULL;
20324 : }
20325 : default:
20326 0 : _raise_ms_exception();
20327 0 : msResetErrorList();
20328 0 : return NULL;
20329 : }
20330 :
20331 : }
20332 : }
20333 : resultobj = SWIG_Py_Void();
20334 1 : return resultobj;
20335 0 : fail:
20336 : return NULL;
20337 : }
20338 :
20339 :
20340 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_getSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20341 : PyObject *resultobj = 0;
20342 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20343 : int arg2 ;
20344 1 : void *argp1 = 0 ;
20345 : int res1 = 0 ;
20346 : int val2 ;
20347 : int ecode2 = 0 ;
20348 1 : PyObject * obj0 = 0 ;
20349 1 : PyObject * obj1 = 0 ;
20350 : symbolObj *result = 0 ;
20351 :
20352 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_getSymbol",&obj0,&obj1)) SWIG_fail;
20353 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20354 1 : if (!SWIG_IsOK(res1)) {
20355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_getSymbol" "', argument " "1"" of type '" "symbolSetObj *""'");
20356 : }
20357 1 : arg1 = (symbolSetObj *)(argp1);
20358 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20359 1 : if (!SWIG_IsOK(ecode2)) {
20360 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_getSymbol" "', argument " "2"" of type '" "int""'");
20361 : }
20362 : arg2 = (int)(val2);
20363 : {
20364 : result = (symbolObj *)symbolSetObj_getSymbol(arg1,arg2); {
20365 1 : errorObj *ms_error = msGetErrorObj();
20366 :
20367 1 : switch(ms_error->code) {
20368 : case MS_NOERR:
20369 : break;
20370 0 : case MS_NOTFOUND:
20371 0 : msResetErrorList();
20372 0 : break;
20373 : case -1:
20374 : break;
20375 0 : case MS_IOERR:
20376 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20377 0 : _raise_ms_exception();
20378 0 : msResetErrorList();
20379 0 : return NULL;
20380 : }
20381 : default:
20382 0 : _raise_ms_exception();
20383 0 : msResetErrorList();
20384 0 : return NULL;
20385 : }
20386 :
20387 : }
20388 : }
20389 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN | 0 );
20390 1 : return resultobj;
20391 0 : fail:
20392 : return NULL;
20393 : }
20394 :
20395 :
20396 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_getSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20397 : PyObject *resultobj = 0;
20398 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20399 : char *arg2 = (char *) 0 ;
20400 1 : void *argp1 = 0 ;
20401 : int res1 = 0 ;
20402 : int res2 ;
20403 1 : char *buf2 = 0 ;
20404 1 : int alloc2 = 0 ;
20405 1 : PyObject * obj0 = 0 ;
20406 1 : PyObject * obj1 = 0 ;
20407 : symbolObj *result = 0 ;
20408 :
20409 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_getSymbolByName",&obj0,&obj1)) SWIG_fail;
20410 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20411 1 : if (!SWIG_IsOK(res1)) {
20412 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_getSymbolByName" "', argument " "1"" of type '" "symbolSetObj *""'");
20413 : }
20414 1 : arg1 = (symbolSetObj *)(argp1);
20415 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20416 1 : if (!SWIG_IsOK(res2)) {
20417 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_getSymbolByName" "', argument " "2"" of type '" "char *""'");
20418 : }
20419 1 : arg2 = (char *)(buf2);
20420 : {
20421 1 : result = (symbolObj *)symbolSetObj_getSymbolByName(arg1,arg2); {
20422 1 : errorObj *ms_error = msGetErrorObj();
20423 :
20424 1 : switch(ms_error->code) {
20425 : case MS_NOERR:
20426 : break;
20427 0 : case MS_NOTFOUND:
20428 0 : msResetErrorList();
20429 0 : break;
20430 : case -1:
20431 : break;
20432 0 : case MS_IOERR:
20433 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20434 0 : _raise_ms_exception();
20435 0 : msResetErrorList();
20436 0 : return NULL;
20437 : }
20438 : default:
20439 0 : _raise_ms_exception();
20440 0 : msResetErrorList();
20441 0 : return NULL;
20442 : }
20443 :
20444 : }
20445 : }
20446 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN | 0 );
20447 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20448 : return resultobj;
20449 0 : fail:
20450 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20451 : return NULL;
20452 : }
20453 :
20454 :
20455 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_index(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20456 : PyObject *resultobj = 0;
20457 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20458 : char *arg2 = (char *) 0 ;
20459 1 : void *argp1 = 0 ;
20460 : int res1 = 0 ;
20461 : int res2 ;
20462 1 : char *buf2 = 0 ;
20463 1 : int alloc2 = 0 ;
20464 1 : PyObject * obj0 = 0 ;
20465 1 : PyObject * obj1 = 0 ;
20466 : int result;
20467 :
20468 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_index",&obj0,&obj1)) SWIG_fail;
20469 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20470 1 : if (!SWIG_IsOK(res1)) {
20471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_index" "', argument " "1"" of type '" "symbolSetObj *""'");
20472 : }
20473 1 : arg1 = (symbolSetObj *)(argp1);
20474 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20475 1 : if (!SWIG_IsOK(res2)) {
20476 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_index" "', argument " "2"" of type '" "char *""'");
20477 : }
20478 1 : arg2 = (char *)(buf2);
20479 : {
20480 : result = (int)symbolSetObj_index(arg1,arg2); {
20481 1 : errorObj *ms_error = msGetErrorObj();
20482 :
20483 1 : switch(ms_error->code) {
20484 : case MS_NOERR:
20485 : break;
20486 0 : case MS_NOTFOUND:
20487 0 : msResetErrorList();
20488 0 : break;
20489 : case -1:
20490 : break;
20491 0 : case MS_IOERR:
20492 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20493 0 : _raise_ms_exception();
20494 0 : msResetErrorList();
20495 0 : return NULL;
20496 : }
20497 : default:
20498 0 : _raise_ms_exception();
20499 0 : msResetErrorList();
20500 0 : return NULL;
20501 : }
20502 :
20503 : }
20504 : }
20505 : resultobj = SWIG_From_int((int)(result));
20506 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20507 : return resultobj;
20508 0 : fail:
20509 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20510 : return NULL;
20511 : }
20512 :
20513 :
20514 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_appendSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20515 : PyObject *resultobj = 0;
20516 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20517 : symbolObj *arg2 = (symbolObj *) 0 ;
20518 1 : void *argp1 = 0 ;
20519 : int res1 = 0 ;
20520 1 : void *argp2 = 0 ;
20521 : int res2 = 0 ;
20522 1 : PyObject * obj0 = 0 ;
20523 1 : PyObject * obj1 = 0 ;
20524 : int result;
20525 :
20526 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_appendSymbol",&obj0,&obj1)) SWIG_fail;
20527 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20528 1 : if (!SWIG_IsOK(res1)) {
20529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_appendSymbol" "', argument " "1"" of type '" "symbolSetObj *""'");
20530 : }
20531 1 : arg1 = (symbolSetObj *)(argp1);
20532 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_symbolObj, 0 | 0 );
20533 1 : if (!SWIG_IsOK(res2)) {
20534 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_appendSymbol" "', argument " "2"" of type '" "symbolObj *""'");
20535 : }
20536 1 : arg2 = (symbolObj *)(argp2);
20537 : {
20538 : result = (int)symbolSetObj_appendSymbol(arg1,arg2); {
20539 1 : errorObj *ms_error = msGetErrorObj();
20540 :
20541 1 : switch(ms_error->code) {
20542 : case MS_NOERR:
20543 : break;
20544 0 : case MS_NOTFOUND:
20545 0 : msResetErrorList();
20546 0 : break;
20547 : case -1:
20548 : break;
20549 0 : case MS_IOERR:
20550 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20551 0 : _raise_ms_exception();
20552 0 : msResetErrorList();
20553 0 : return NULL;
20554 : }
20555 : default:
20556 0 : _raise_ms_exception();
20557 0 : msResetErrorList();
20558 0 : return NULL;
20559 : }
20560 :
20561 : }
20562 : }
20563 : resultobj = SWIG_From_int((int)(result));
20564 1 : return resultobj;
20565 0 : fail:
20566 : return NULL;
20567 : }
20568 :
20569 :
20570 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_removeSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20571 : PyObject *resultobj = 0;
20572 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20573 : int arg2 ;
20574 1 : void *argp1 = 0 ;
20575 : int res1 = 0 ;
20576 : int val2 ;
20577 : int ecode2 = 0 ;
20578 1 : PyObject * obj0 = 0 ;
20579 1 : PyObject * obj1 = 0 ;
20580 : symbolObj *result = 0 ;
20581 :
20582 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_removeSymbol",&obj0,&obj1)) SWIG_fail;
20583 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20584 1 : if (!SWIG_IsOK(res1)) {
20585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_removeSymbol" "', argument " "1"" of type '" "symbolSetObj *""'");
20586 : }
20587 1 : arg1 = (symbolSetObj *)(argp1);
20588 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20589 1 : if (!SWIG_IsOK(ecode2)) {
20590 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolSetObj_removeSymbol" "', argument " "2"" of type '" "int""'");
20591 : }
20592 : arg2 = (int)(val2);
20593 : {
20594 1 : result = (symbolObj *)symbolSetObj_removeSymbol(arg1,arg2); {
20595 1 : errorObj *ms_error = msGetErrorObj();
20596 :
20597 1 : switch(ms_error->code) {
20598 : case MS_NOERR:
20599 : break;
20600 0 : case MS_NOTFOUND:
20601 0 : msResetErrorList();
20602 0 : break;
20603 : case -1:
20604 : break;
20605 0 : case MS_IOERR:
20606 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20607 0 : _raise_ms_exception();
20608 0 : msResetErrorList();
20609 0 : return NULL;
20610 : }
20611 : default:
20612 0 : _raise_ms_exception();
20613 0 : msResetErrorList();
20614 0 : return NULL;
20615 : }
20616 :
20617 : }
20618 : }
20619 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_OWN | 0 );
20620 1 : return resultobj;
20621 0 : fail:
20622 : return NULL;
20623 : }
20624 :
20625 :
20626 1 : SWIGINTERN PyObject *_wrap_symbolSetObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20627 : PyObject *resultobj = 0;
20628 : symbolSetObj *arg1 = (symbolSetObj *) 0 ;
20629 : char *arg2 = (char *) 0 ;
20630 1 : void *argp1 = 0 ;
20631 : int res1 = 0 ;
20632 : int res2 ;
20633 1 : char *buf2 = 0 ;
20634 1 : int alloc2 = 0 ;
20635 1 : PyObject * obj0 = 0 ;
20636 1 : PyObject * obj1 = 0 ;
20637 : int result;
20638 :
20639 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolSetObj_save",&obj0,&obj1)) SWIG_fail;
20640 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolSetObj, 0 | 0 );
20641 1 : if (!SWIG_IsOK(res1)) {
20642 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolSetObj_save" "', argument " "1"" of type '" "symbolSetObj *""'");
20643 : }
20644 1 : arg1 = (symbolSetObj *)(argp1);
20645 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20646 1 : if (!SWIG_IsOK(res2)) {
20647 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolSetObj_save" "', argument " "2"" of type '" "char const *""'");
20648 : }
20649 1 : arg2 = (char *)(buf2);
20650 : {
20651 : result = (int)symbolSetObj_save(arg1,(char const *)arg2); {
20652 1 : errorObj *ms_error = msGetErrorObj();
20653 :
20654 1 : switch(ms_error->code) {
20655 : case MS_NOERR:
20656 : break;
20657 0 : case MS_NOTFOUND:
20658 0 : msResetErrorList();
20659 0 : break;
20660 : case -1:
20661 : break;
20662 0 : case MS_IOERR:
20663 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
20664 0 : _raise_ms_exception();
20665 0 : msResetErrorList();
20666 0 : return NULL;
20667 : }
20668 : default:
20669 1 : _raise_ms_exception();
20670 1 : msResetErrorList();
20671 1 : return NULL;
20672 : }
20673 :
20674 : }
20675 : }
20676 : resultobj = SWIG_From_int((int)(result));
20677 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20678 : return resultobj;
20679 0 : fail:
20680 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20681 : return NULL;
20682 : }
20683 :
20684 :
20685 1 : SWIGINTERN PyObject *symbolSetObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20686 : PyObject *obj;
20687 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
20688 1 : SWIG_TypeNewClientData(SWIGTYPE_p_symbolSetObj, SWIG_NewClientData(obj));
20689 1 : return SWIG_Py_Void();
20690 : }
20691 :
20692 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20693 : PyObject *resultobj = 0;
20694 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20695 : rectObj *arg2 = (rectObj *) 0 ;
20696 0 : void *argp1 = 0 ;
20697 : int res1 = 0 ;
20698 0 : void *argp2 = 0 ;
20699 : int res2 = 0 ;
20700 0 : PyObject * obj0 = 0 ;
20701 0 : PyObject * obj1 = 0 ;
20702 :
20703 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_extent_set",&obj0,&obj1)) SWIG_fail;
20704 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20705 0 : if (!SWIG_IsOK(res1)) {
20706 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_extent_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20707 : }
20708 0 : arg1 = (referenceMapObj *)(argp1);
20709 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 | 0 );
20710 0 : if (!SWIG_IsOK(res2)) {
20711 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_extent_set" "', argument " "2"" of type '" "rectObj *""'");
20712 : }
20713 0 : arg2 = (rectObj *)(argp2);
20714 0 : if (arg1) (arg1)->extent = *arg2;
20715 : resultobj = SWIG_Py_Void();
20716 0 : return resultobj;
20717 0 : fail:
20718 : return NULL;
20719 : }
20720 :
20721 :
20722 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20723 : PyObject *resultobj = 0;
20724 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20725 0 : void *argp1 = 0 ;
20726 : int res1 = 0 ;
20727 0 : PyObject * obj0 = 0 ;
20728 : rectObj *result = 0 ;
20729 :
20730 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_extent_get",&obj0)) SWIG_fail;
20731 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20732 0 : if (!SWIG_IsOK(res1)) {
20733 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_extent_get" "', argument " "1"" of type '" "referenceMapObj *""'");
20734 : }
20735 0 : arg1 = (referenceMapObj *)(argp1);
20736 0 : result = (rectObj *)& ((arg1)->extent);
20737 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
20738 0 : return resultobj;
20739 0 : fail:
20740 : return NULL;
20741 : }
20742 :
20743 :
20744 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 : PyObject *resultobj = 0;
20746 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20747 : int arg2 ;
20748 0 : void *argp1 = 0 ;
20749 : int res1 = 0 ;
20750 : int val2 ;
20751 : int ecode2 = 0 ;
20752 0 : PyObject * obj0 = 0 ;
20753 0 : PyObject * obj1 = 0 ;
20754 :
20755 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_height_set",&obj0,&obj1)) SWIG_fail;
20756 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20757 0 : if (!SWIG_IsOK(res1)) {
20758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_height_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20759 : }
20760 0 : arg1 = (referenceMapObj *)(argp1);
20761 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20762 0 : if (!SWIG_IsOK(ecode2)) {
20763 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_height_set" "', argument " "2"" of type '" "int""'");
20764 : }
20765 : arg2 = (int)(val2);
20766 0 : if (arg1) (arg1)->height = arg2;
20767 : resultobj = SWIG_Py_Void();
20768 0 : return resultobj;
20769 0 : fail:
20770 : return NULL;
20771 : }
20772 :
20773 :
20774 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20775 : PyObject *resultobj = 0;
20776 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20777 0 : void *argp1 = 0 ;
20778 : int res1 = 0 ;
20779 0 : PyObject * obj0 = 0 ;
20780 : int result;
20781 :
20782 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_height_get",&obj0)) SWIG_fail;
20783 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20784 0 : if (!SWIG_IsOK(res1)) {
20785 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_height_get" "', argument " "1"" of type '" "referenceMapObj *""'");
20786 : }
20787 0 : arg1 = (referenceMapObj *)(argp1);
20788 0 : result = (int) ((arg1)->height);
20789 : resultobj = SWIG_From_int((int)(result));
20790 0 : return resultobj;
20791 0 : fail:
20792 : return NULL;
20793 : }
20794 :
20795 :
20796 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20797 : PyObject *resultobj = 0;
20798 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20799 : int arg2 ;
20800 0 : void *argp1 = 0 ;
20801 : int res1 = 0 ;
20802 : int val2 ;
20803 : int ecode2 = 0 ;
20804 0 : PyObject * obj0 = 0 ;
20805 0 : PyObject * obj1 = 0 ;
20806 :
20807 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_width_set",&obj0,&obj1)) SWIG_fail;
20808 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20809 0 : if (!SWIG_IsOK(res1)) {
20810 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_width_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20811 : }
20812 0 : arg1 = (referenceMapObj *)(argp1);
20813 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
20814 0 : if (!SWIG_IsOK(ecode2)) {
20815 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_width_set" "', argument " "2"" of type '" "int""'");
20816 : }
20817 : arg2 = (int)(val2);
20818 0 : if (arg1) (arg1)->width = arg2;
20819 : resultobj = SWIG_Py_Void();
20820 0 : return resultobj;
20821 0 : fail:
20822 : return NULL;
20823 : }
20824 :
20825 :
20826 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20827 : PyObject *resultobj = 0;
20828 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20829 0 : void *argp1 = 0 ;
20830 : int res1 = 0 ;
20831 0 : PyObject * obj0 = 0 ;
20832 : int result;
20833 :
20834 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_width_get",&obj0)) SWIG_fail;
20835 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20836 0 : if (!SWIG_IsOK(res1)) {
20837 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_width_get" "', argument " "1"" of type '" "referenceMapObj *""'");
20838 : }
20839 0 : arg1 = (referenceMapObj *)(argp1);
20840 0 : result = (int) ((arg1)->width);
20841 : resultobj = SWIG_From_int((int)(result));
20842 0 : return resultobj;
20843 0 : fail:
20844 : return NULL;
20845 : }
20846 :
20847 :
20848 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20849 : PyObject *resultobj = 0;
20850 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20851 : colorObj *arg2 = (colorObj *) 0 ;
20852 0 : void *argp1 = 0 ;
20853 : int res1 = 0 ;
20854 0 : void *argp2 = 0 ;
20855 : int res2 = 0 ;
20856 0 : PyObject * obj0 = 0 ;
20857 0 : PyObject * obj1 = 0 ;
20858 :
20859 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_color_set",&obj0,&obj1)) SWIG_fail;
20860 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20861 0 : if (!SWIG_IsOK(res1)) {
20862 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_color_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20863 : }
20864 0 : arg1 = (referenceMapObj *)(argp1);
20865 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
20866 0 : if (!SWIG_IsOK(res2)) {
20867 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_color_set" "', argument " "2"" of type '" "colorObj *""'");
20868 : }
20869 0 : arg2 = (colorObj *)(argp2);
20870 0 : if (arg1) (arg1)->color = *arg2;
20871 : resultobj = SWIG_Py_Void();
20872 0 : return resultobj;
20873 0 : fail:
20874 : return NULL;
20875 : }
20876 :
20877 :
20878 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20879 : PyObject *resultobj = 0;
20880 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20881 0 : void *argp1 = 0 ;
20882 : int res1 = 0 ;
20883 0 : PyObject * obj0 = 0 ;
20884 : colorObj *result = 0 ;
20885 :
20886 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_color_get",&obj0)) SWIG_fail;
20887 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20888 0 : if (!SWIG_IsOK(res1)) {
20889 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_color_get" "', argument " "1"" of type '" "referenceMapObj *""'");
20890 : }
20891 0 : arg1 = (referenceMapObj *)(argp1);
20892 0 : result = (colorObj *)& ((arg1)->color);
20893 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
20894 0 : return resultobj;
20895 0 : fail:
20896 : return NULL;
20897 : }
20898 :
20899 :
20900 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20901 : PyObject *resultobj = 0;
20902 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20903 : colorObj *arg2 = (colorObj *) 0 ;
20904 0 : void *argp1 = 0 ;
20905 : int res1 = 0 ;
20906 0 : void *argp2 = 0 ;
20907 : int res2 = 0 ;
20908 0 : PyObject * obj0 = 0 ;
20909 0 : PyObject * obj1 = 0 ;
20910 :
20911 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
20912 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20913 0 : if (!SWIG_IsOK(res1)) {
20914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_outlinecolor_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20915 : }
20916 0 : arg1 = (referenceMapObj *)(argp1);
20917 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
20918 0 : if (!SWIG_IsOK(res2)) {
20919 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'");
20920 : }
20921 0 : arg2 = (colorObj *)(argp2);
20922 0 : if (arg1) (arg1)->outlinecolor = *arg2;
20923 : resultobj = SWIG_Py_Void();
20924 0 : return resultobj;
20925 0 : fail:
20926 : return NULL;
20927 : }
20928 :
20929 :
20930 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20931 : PyObject *resultobj = 0;
20932 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20933 0 : void *argp1 = 0 ;
20934 : int res1 = 0 ;
20935 0 : PyObject * obj0 = 0 ;
20936 : colorObj *result = 0 ;
20937 :
20938 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_outlinecolor_get",&obj0)) SWIG_fail;
20939 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20940 0 : if (!SWIG_IsOK(res1)) {
20941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_outlinecolor_get" "', argument " "1"" of type '" "referenceMapObj *""'");
20942 : }
20943 0 : arg1 = (referenceMapObj *)(argp1);
20944 0 : result = (colorObj *)& ((arg1)->outlinecolor);
20945 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
20946 0 : return resultobj;
20947 0 : fail:
20948 : return NULL;
20949 : }
20950 :
20951 :
20952 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_image_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20953 : PyObject *resultobj = 0;
20954 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20955 : char *arg2 = (char *) 0 ;
20956 0 : void *argp1 = 0 ;
20957 : int res1 = 0 ;
20958 : int res2 ;
20959 0 : char *buf2 = 0 ;
20960 0 : int alloc2 = 0 ;
20961 0 : PyObject * obj0 = 0 ;
20962 0 : PyObject * obj1 = 0 ;
20963 :
20964 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_image_set",&obj0,&obj1)) SWIG_fail;
20965 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
20966 0 : if (!SWIG_IsOK(res1)) {
20967 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_image_set" "', argument " "1"" of type '" "referenceMapObj *""'");
20968 : }
20969 0 : arg1 = (referenceMapObj *)(argp1);
20970 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20971 0 : if (!SWIG_IsOK(res2)) {
20972 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_image_set" "', argument " "2"" of type '" "char *""'");
20973 : }
20974 0 : arg2 = (char *)(buf2);
20975 : {
20976 0 : if (arg1->image) free((char*)arg1->image);
20977 0 : if (arg2) {
20978 0 : arg1->image = (char *) malloc(strlen(arg2)+1);
20979 : strcpy((char*)arg1->image,arg2);
20980 : } else {
20981 0 : arg1->image = 0;
20982 : }
20983 : }
20984 : resultobj = SWIG_Py_Void();
20985 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20986 : return resultobj;
20987 0 : fail:
20988 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20989 : return NULL;
20990 : }
20991 :
20992 :
20993 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_image_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20994 : PyObject *resultobj = 0;
20995 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
20996 0 : void *argp1 = 0 ;
20997 : int res1 = 0 ;
20998 0 : PyObject * obj0 = 0 ;
20999 : char *result = 0 ;
21000 :
21001 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_image_get",&obj0)) SWIG_fail;
21002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21003 0 : if (!SWIG_IsOK(res1)) {
21004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_image_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21005 : }
21006 0 : arg1 = (referenceMapObj *)(argp1);
21007 0 : result = (char *) ((arg1)->image);
21008 0 : resultobj = SWIG_FromCharPtr((const char *)result);
21009 0 : return resultobj;
21010 0 : fail:
21011 : return NULL;
21012 : }
21013 :
21014 :
21015 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21016 : PyObject *resultobj = 0;
21017 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21018 : int arg2 ;
21019 0 : void *argp1 = 0 ;
21020 : int res1 = 0 ;
21021 : int val2 ;
21022 : int ecode2 = 0 ;
21023 0 : PyObject * obj0 = 0 ;
21024 0 : PyObject * obj1 = 0 ;
21025 :
21026 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_status_set",&obj0,&obj1)) SWIG_fail;
21027 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21028 0 : if (!SWIG_IsOK(res1)) {
21029 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_status_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21030 : }
21031 0 : arg1 = (referenceMapObj *)(argp1);
21032 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21033 0 : if (!SWIG_IsOK(ecode2)) {
21034 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_status_set" "', argument " "2"" of type '" "int""'");
21035 : }
21036 : arg2 = (int)(val2);
21037 0 : if (arg1) (arg1)->status = arg2;
21038 : resultobj = SWIG_Py_Void();
21039 0 : return resultobj;
21040 0 : fail:
21041 : return NULL;
21042 : }
21043 :
21044 :
21045 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 : PyObject *resultobj = 0;
21047 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21048 0 : void *argp1 = 0 ;
21049 : int res1 = 0 ;
21050 0 : PyObject * obj0 = 0 ;
21051 : int result;
21052 :
21053 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_status_get",&obj0)) SWIG_fail;
21054 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21055 0 : if (!SWIG_IsOK(res1)) {
21056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_status_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21057 : }
21058 0 : arg1 = (referenceMapObj *)(argp1);
21059 0 : result = (int) ((arg1)->status);
21060 : resultobj = SWIG_From_int((int)(result));
21061 0 : return resultobj;
21062 0 : fail:
21063 : return NULL;
21064 : }
21065 :
21066 :
21067 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_marker_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21068 : PyObject *resultobj = 0;
21069 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21070 : int arg2 ;
21071 0 : void *argp1 = 0 ;
21072 : int res1 = 0 ;
21073 : int val2 ;
21074 : int ecode2 = 0 ;
21075 0 : PyObject * obj0 = 0 ;
21076 0 : PyObject * obj1 = 0 ;
21077 :
21078 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_marker_set",&obj0,&obj1)) SWIG_fail;
21079 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21080 0 : if (!SWIG_IsOK(res1)) {
21081 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_marker_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21082 : }
21083 0 : arg1 = (referenceMapObj *)(argp1);
21084 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21085 0 : if (!SWIG_IsOK(ecode2)) {
21086 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_marker_set" "', argument " "2"" of type '" "int""'");
21087 : }
21088 : arg2 = (int)(val2);
21089 0 : if (arg1) (arg1)->marker = arg2;
21090 : resultobj = SWIG_Py_Void();
21091 0 : return resultobj;
21092 0 : fail:
21093 : return NULL;
21094 : }
21095 :
21096 :
21097 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_marker_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21098 : PyObject *resultobj = 0;
21099 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21100 0 : void *argp1 = 0 ;
21101 : int res1 = 0 ;
21102 0 : PyObject * obj0 = 0 ;
21103 : int result;
21104 :
21105 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_marker_get",&obj0)) SWIG_fail;
21106 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21107 0 : if (!SWIG_IsOK(res1)) {
21108 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_marker_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21109 : }
21110 0 : arg1 = (referenceMapObj *)(argp1);
21111 0 : result = (int) ((arg1)->marker);
21112 : resultobj = SWIG_From_int((int)(result));
21113 0 : return resultobj;
21114 0 : fail:
21115 : return NULL;
21116 : }
21117 :
21118 :
21119 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markername_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21120 : PyObject *resultobj = 0;
21121 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21122 : char *arg2 = (char *) 0 ;
21123 0 : void *argp1 = 0 ;
21124 : int res1 = 0 ;
21125 : int res2 ;
21126 0 : char *buf2 = 0 ;
21127 0 : int alloc2 = 0 ;
21128 0 : PyObject * obj0 = 0 ;
21129 0 : PyObject * obj1 = 0 ;
21130 :
21131 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_markername_set",&obj0,&obj1)) SWIG_fail;
21132 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21133 0 : if (!SWIG_IsOK(res1)) {
21134 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markername_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21135 : }
21136 0 : arg1 = (referenceMapObj *)(argp1);
21137 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21138 0 : if (!SWIG_IsOK(res2)) {
21139 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_markername_set" "', argument " "2"" of type '" "char *""'");
21140 : }
21141 0 : arg2 = (char *)(buf2);
21142 : {
21143 0 : if (arg1->markername) free((char*)arg1->markername);
21144 0 : if (arg2) {
21145 0 : arg1->markername = (char *) malloc(strlen(arg2)+1);
21146 : strcpy((char*)arg1->markername,arg2);
21147 : } else {
21148 0 : arg1->markername = 0;
21149 : }
21150 : }
21151 : resultobj = SWIG_Py_Void();
21152 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21153 : return resultobj;
21154 0 : fail:
21155 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21156 : return NULL;
21157 : }
21158 :
21159 :
21160 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markername_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21161 : PyObject *resultobj = 0;
21162 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21163 0 : void *argp1 = 0 ;
21164 : int res1 = 0 ;
21165 0 : PyObject * obj0 = 0 ;
21166 : char *result = 0 ;
21167 :
21168 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_markername_get",&obj0)) SWIG_fail;
21169 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21170 0 : if (!SWIG_IsOK(res1)) {
21171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markername_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21172 : }
21173 0 : arg1 = (referenceMapObj *)(argp1);
21174 0 : result = (char *) ((arg1)->markername);
21175 0 : resultobj = SWIG_FromCharPtr((const char *)result);
21176 0 : return resultobj;
21177 0 : fail:
21178 : return NULL;
21179 : }
21180 :
21181 :
21182 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markersize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21183 : PyObject *resultobj = 0;
21184 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21185 : int arg2 ;
21186 0 : void *argp1 = 0 ;
21187 : int res1 = 0 ;
21188 : int val2 ;
21189 : int ecode2 = 0 ;
21190 0 : PyObject * obj0 = 0 ;
21191 0 : PyObject * obj1 = 0 ;
21192 :
21193 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_markersize_set",&obj0,&obj1)) SWIG_fail;
21194 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21195 0 : if (!SWIG_IsOK(res1)) {
21196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markersize_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21197 : }
21198 0 : arg1 = (referenceMapObj *)(argp1);
21199 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21200 0 : if (!SWIG_IsOK(ecode2)) {
21201 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_markersize_set" "', argument " "2"" of type '" "int""'");
21202 : }
21203 : arg2 = (int)(val2);
21204 0 : if (arg1) (arg1)->markersize = arg2;
21205 : resultobj = SWIG_Py_Void();
21206 0 : return resultobj;
21207 0 : fail:
21208 : return NULL;
21209 : }
21210 :
21211 :
21212 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_markersize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21213 : PyObject *resultobj = 0;
21214 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21215 0 : void *argp1 = 0 ;
21216 : int res1 = 0 ;
21217 0 : PyObject * obj0 = 0 ;
21218 : int result;
21219 :
21220 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_markersize_get",&obj0)) SWIG_fail;
21221 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21222 0 : if (!SWIG_IsOK(res1)) {
21223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_markersize_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21224 : }
21225 0 : arg1 = (referenceMapObj *)(argp1);
21226 0 : result = (int) ((arg1)->markersize);
21227 : resultobj = SWIG_From_int((int)(result));
21228 0 : return resultobj;
21229 0 : fail:
21230 : return NULL;
21231 : }
21232 :
21233 :
21234 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_minboxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21235 : PyObject *resultobj = 0;
21236 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21237 : int arg2 ;
21238 0 : void *argp1 = 0 ;
21239 : int res1 = 0 ;
21240 : int val2 ;
21241 : int ecode2 = 0 ;
21242 0 : PyObject * obj0 = 0 ;
21243 0 : PyObject * obj1 = 0 ;
21244 :
21245 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_minboxsize_set",&obj0,&obj1)) SWIG_fail;
21246 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21247 0 : if (!SWIG_IsOK(res1)) {
21248 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_minboxsize_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21249 : }
21250 0 : arg1 = (referenceMapObj *)(argp1);
21251 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21252 0 : if (!SWIG_IsOK(ecode2)) {
21253 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_minboxsize_set" "', argument " "2"" of type '" "int""'");
21254 : }
21255 : arg2 = (int)(val2);
21256 0 : if (arg1) (arg1)->minboxsize = arg2;
21257 : resultobj = SWIG_Py_Void();
21258 0 : return resultobj;
21259 0 : fail:
21260 : return NULL;
21261 : }
21262 :
21263 :
21264 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_minboxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21265 : PyObject *resultobj = 0;
21266 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21267 0 : void *argp1 = 0 ;
21268 : int res1 = 0 ;
21269 0 : PyObject * obj0 = 0 ;
21270 : int result;
21271 :
21272 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_minboxsize_get",&obj0)) SWIG_fail;
21273 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21274 0 : if (!SWIG_IsOK(res1)) {
21275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_minboxsize_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21276 : }
21277 0 : arg1 = (referenceMapObj *)(argp1);
21278 0 : result = (int) ((arg1)->minboxsize);
21279 : resultobj = SWIG_From_int((int)(result));
21280 0 : return resultobj;
21281 0 : fail:
21282 : return NULL;
21283 : }
21284 :
21285 :
21286 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_maxboxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21287 : PyObject *resultobj = 0;
21288 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21289 : int arg2 ;
21290 0 : void *argp1 = 0 ;
21291 : int res1 = 0 ;
21292 : int val2 ;
21293 : int ecode2 = 0 ;
21294 0 : PyObject * obj0 = 0 ;
21295 0 : PyObject * obj1 = 0 ;
21296 :
21297 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_maxboxsize_set",&obj0,&obj1)) SWIG_fail;
21298 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21299 0 : if (!SWIG_IsOK(res1)) {
21300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_maxboxsize_set" "', argument " "1"" of type '" "referenceMapObj *""'");
21301 : }
21302 0 : arg1 = (referenceMapObj *)(argp1);
21303 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21304 0 : if (!SWIG_IsOK(ecode2)) {
21305 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "referenceMapObj_maxboxsize_set" "', argument " "2"" of type '" "int""'");
21306 : }
21307 : arg2 = (int)(val2);
21308 0 : if (arg1) (arg1)->maxboxsize = arg2;
21309 : resultobj = SWIG_Py_Void();
21310 0 : return resultobj;
21311 0 : fail:
21312 : return NULL;
21313 : }
21314 :
21315 :
21316 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_maxboxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21317 : PyObject *resultobj = 0;
21318 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21319 0 : void *argp1 = 0 ;
21320 : int res1 = 0 ;
21321 0 : PyObject * obj0 = 0 ;
21322 : int result;
21323 :
21324 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_maxboxsize_get",&obj0)) SWIG_fail;
21325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21326 0 : if (!SWIG_IsOK(res1)) {
21327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_maxboxsize_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21328 : }
21329 0 : arg1 = (referenceMapObj *)(argp1);
21330 0 : result = (int) ((arg1)->maxboxsize);
21331 : resultobj = SWIG_From_int((int)(result));
21332 0 : return resultobj;
21333 0 : fail:
21334 : return NULL;
21335 : }
21336 :
21337 :
21338 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21339 : PyObject *resultobj = 0;
21340 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21341 0 : void *argp1 = 0 ;
21342 : int res1 = 0 ;
21343 0 : PyObject * obj0 = 0 ;
21344 : struct mapObj *result = 0 ;
21345 :
21346 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_map_get",&obj0)) SWIG_fail;
21347 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21348 0 : if (!SWIG_IsOK(res1)) {
21349 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_map_get" "', argument " "1"" of type '" "referenceMapObj *""'");
21350 : }
21351 0 : arg1 = (referenceMapObj *)(argp1);
21352 0 : result = (struct mapObj *) ((arg1)->map);
21353 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 | 0 );
21354 0 : return resultobj;
21355 0 : fail:
21356 : return NULL;
21357 : }
21358 :
21359 :
21360 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21361 : PyObject *resultobj = 0;
21362 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21363 : char *arg2 = (char *) 0 ;
21364 0 : void *argp1 = 0 ;
21365 : int res1 = 0 ;
21366 : int res2 ;
21367 0 : char *buf2 = 0 ;
21368 0 : int alloc2 = 0 ;
21369 0 : PyObject * obj0 = 0 ;
21370 0 : PyObject * obj1 = 0 ;
21371 : int result;
21372 :
21373 0 : if (!PyArg_ParseTuple(args,(char *)"OO:referenceMapObj_updateFromString",&obj0,&obj1)) SWIG_fail;
21374 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21375 0 : if (!SWIG_IsOK(res1)) {
21376 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_updateFromString" "', argument " "1"" of type '" "referenceMapObj *""'");
21377 : }
21378 0 : arg1 = (referenceMapObj *)(argp1);
21379 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21380 0 : if (!SWIG_IsOK(res2)) {
21381 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "referenceMapObj_updateFromString" "', argument " "2"" of type '" "char *""'");
21382 : }
21383 0 : arg2 = (char *)(buf2);
21384 : {
21385 : result = (int)referenceMapObj_updateFromString(arg1,arg2); {
21386 0 : errorObj *ms_error = msGetErrorObj();
21387 :
21388 0 : switch(ms_error->code) {
21389 : case MS_NOERR:
21390 : break;
21391 0 : case MS_NOTFOUND:
21392 0 : msResetErrorList();
21393 0 : break;
21394 : case -1:
21395 : break;
21396 0 : case MS_IOERR:
21397 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
21398 0 : _raise_ms_exception();
21399 0 : msResetErrorList();
21400 0 : return NULL;
21401 : }
21402 : default:
21403 0 : _raise_ms_exception();
21404 0 : msResetErrorList();
21405 0 : return NULL;
21406 : }
21407 :
21408 : }
21409 : }
21410 : resultobj = SWIG_From_int((int)(result));
21411 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21412 : return resultobj;
21413 0 : fail:
21414 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21415 : return NULL;
21416 : }
21417 :
21418 :
21419 0 : SWIGINTERN PyObject *_wrap_referenceMapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21420 : PyObject *resultobj = 0;
21421 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21422 0 : void *argp1 = 0 ;
21423 : int res1 = 0 ;
21424 0 : PyObject * obj0 = 0 ;
21425 : char *result = 0 ;
21426 :
21427 0 : if (!PyArg_ParseTuple(args,(char *)"O:referenceMapObj_convertToString",&obj0)) SWIG_fail;
21428 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, 0 | 0 );
21429 0 : if (!SWIG_IsOK(res1)) {
21430 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "referenceMapObj_convertToString" "', argument " "1"" of type '" "referenceMapObj *""'");
21431 : }
21432 0 : arg1 = (referenceMapObj *)(argp1);
21433 : {
21434 : result = (char *)referenceMapObj_convertToString(arg1); {
21435 0 : errorObj *ms_error = msGetErrorObj();
21436 :
21437 0 : switch(ms_error->code) {
21438 : case MS_NOERR:
21439 : break;
21440 0 : case MS_NOTFOUND:
21441 0 : msResetErrorList();
21442 0 : break;
21443 : case -1:
21444 : break;
21445 0 : case MS_IOERR:
21446 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
21447 0 : _raise_ms_exception();
21448 0 : msResetErrorList();
21449 0 : return NULL;
21450 : }
21451 : default:
21452 0 : _raise_ms_exception();
21453 0 : msResetErrorList();
21454 0 : return NULL;
21455 : }
21456 :
21457 : }
21458 : }
21459 0 : resultobj = SWIG_FromCharPtr((const char *)result);
21460 0 : free((char*)result);
21461 0 : return resultobj;
21462 0 : fail:
21463 : return NULL;
21464 : }
21465 :
21466 :
21467 0 : SWIGINTERN PyObject *_wrap_new_referenceMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21468 : PyObject *resultobj = 0;
21469 : referenceMapObj *result = 0 ;
21470 :
21471 0 : if (!PyArg_ParseTuple(args,(char *)":new_referenceMapObj")) SWIG_fail;
21472 : {
21473 0 : result = (referenceMapObj *)calloc(1, sizeof(referenceMapObj)); {
21474 0 : errorObj *ms_error = msGetErrorObj();
21475 :
21476 0 : switch(ms_error->code) {
21477 : case MS_NOERR:
21478 : break;
21479 0 : case MS_NOTFOUND:
21480 0 : msResetErrorList();
21481 0 : break;
21482 : case -1:
21483 : break;
21484 0 : case MS_IOERR:
21485 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
21486 0 : _raise_ms_exception();
21487 0 : msResetErrorList();
21488 0 : return NULL;
21489 : }
21490 : default:
21491 0 : _raise_ms_exception();
21492 0 : msResetErrorList();
21493 0 : return NULL;
21494 : }
21495 :
21496 : }
21497 : }
21498 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_referenceMapObj, SWIG_POINTER_NEW | 0 );
21499 0 : return resultobj;
21500 0 : fail:
21501 : return NULL;
21502 : }
21503 :
21504 :
21505 0 : SWIGINTERN PyObject *_wrap_delete_referenceMapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21506 : PyObject *resultobj = 0;
21507 : referenceMapObj *arg1 = (referenceMapObj *) 0 ;
21508 0 : void *argp1 = 0 ;
21509 : int res1 = 0 ;
21510 0 : PyObject * obj0 = 0 ;
21511 :
21512 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_referenceMapObj",&obj0)) SWIG_fail;
21513 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_referenceMapObj, SWIG_POINTER_DISOWN | 0 );
21514 0 : if (!SWIG_IsOK(res1)) {
21515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_referenceMapObj" "', argument " "1"" of type '" "referenceMapObj *""'");
21516 : }
21517 0 : arg1 = (referenceMapObj *)(argp1);
21518 : {
21519 0 : free((char *) arg1); {
21520 0 : errorObj *ms_error = msGetErrorObj();
21521 :
21522 0 : switch(ms_error->code) {
21523 : case MS_NOERR:
21524 : break;
21525 0 : case MS_NOTFOUND:
21526 0 : msResetErrorList();
21527 0 : break;
21528 : case -1:
21529 : break;
21530 0 : case MS_IOERR:
21531 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
21532 0 : _raise_ms_exception();
21533 0 : msResetErrorList();
21534 0 : return NULL;
21535 : }
21536 : default:
21537 0 : _raise_ms_exception();
21538 0 : msResetErrorList();
21539 0 : return NULL;
21540 : }
21541 :
21542 : }
21543 : }
21544 : resultobj = SWIG_Py_Void();
21545 0 : return resultobj;
21546 0 : fail:
21547 : return NULL;
21548 : }
21549 :
21550 :
21551 1 : SWIGINTERN PyObject *referenceMapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21552 : PyObject *obj;
21553 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
21554 1 : SWIG_TypeNewClientData(SWIGTYPE_p_referenceMapObj, SWIG_NewClientData(obj));
21555 1 : return SWIG_Py_Void();
21556 : }
21557 :
21558 0 : SWIGINTERN PyObject *_wrap_scalebarObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21559 : PyObject *resultobj = 0;
21560 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21561 : colorObj *arg2 = (colorObj *) 0 ;
21562 0 : void *argp1 = 0 ;
21563 : int res1 = 0 ;
21564 0 : void *argp2 = 0 ;
21565 : int res2 = 0 ;
21566 0 : PyObject * obj0 = 0 ;
21567 0 : PyObject * obj1 = 0 ;
21568 :
21569 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
21570 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21571 0 : if (!SWIG_IsOK(res1)) {
21572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_imagecolor_set" "', argument " "1"" of type '" "scalebarObj *""'");
21573 : }
21574 0 : arg1 = (scalebarObj *)(argp1);
21575 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
21576 0 : if (!SWIG_IsOK(res2)) {
21577 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'");
21578 : }
21579 0 : arg2 = (colorObj *)(argp2);
21580 0 : if (arg1) (arg1)->imagecolor = *arg2;
21581 : resultobj = SWIG_Py_Void();
21582 0 : return resultobj;
21583 0 : fail:
21584 : return NULL;
21585 : }
21586 :
21587 :
21588 0 : SWIGINTERN PyObject *_wrap_scalebarObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21589 : PyObject *resultobj = 0;
21590 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21591 0 : void *argp1 = 0 ;
21592 : int res1 = 0 ;
21593 0 : PyObject * obj0 = 0 ;
21594 : colorObj *result = 0 ;
21595 :
21596 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_imagecolor_get",&obj0)) SWIG_fail;
21597 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21598 0 : if (!SWIG_IsOK(res1)) {
21599 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_imagecolor_get" "', argument " "1"" of type '" "scalebarObj *""'");
21600 : }
21601 0 : arg1 = (scalebarObj *)(argp1);
21602 0 : result = (colorObj *)& ((arg1)->imagecolor);
21603 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
21604 0 : return resultobj;
21605 0 : fail:
21606 : return NULL;
21607 : }
21608 :
21609 :
21610 0 : SWIGINTERN PyObject *_wrap_scalebarObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21611 : PyObject *resultobj = 0;
21612 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21613 : int arg2 ;
21614 0 : void *argp1 = 0 ;
21615 : int res1 = 0 ;
21616 : int val2 ;
21617 : int ecode2 = 0 ;
21618 0 : PyObject * obj0 = 0 ;
21619 0 : PyObject * obj1 = 0 ;
21620 :
21621 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_height_set",&obj0,&obj1)) SWIG_fail;
21622 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21623 0 : if (!SWIG_IsOK(res1)) {
21624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_height_set" "', argument " "1"" of type '" "scalebarObj *""'");
21625 : }
21626 0 : arg1 = (scalebarObj *)(argp1);
21627 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21628 0 : if (!SWIG_IsOK(ecode2)) {
21629 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_height_set" "', argument " "2"" of type '" "int""'");
21630 : }
21631 : arg2 = (int)(val2);
21632 0 : if (arg1) (arg1)->height = arg2;
21633 : resultobj = SWIG_Py_Void();
21634 0 : return resultobj;
21635 0 : fail:
21636 : return NULL;
21637 : }
21638 :
21639 :
21640 0 : SWIGINTERN PyObject *_wrap_scalebarObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21641 : PyObject *resultobj = 0;
21642 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21643 0 : void *argp1 = 0 ;
21644 : int res1 = 0 ;
21645 0 : PyObject * obj0 = 0 ;
21646 : int result;
21647 :
21648 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_height_get",&obj0)) SWIG_fail;
21649 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21650 0 : if (!SWIG_IsOK(res1)) {
21651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_height_get" "', argument " "1"" of type '" "scalebarObj *""'");
21652 : }
21653 0 : arg1 = (scalebarObj *)(argp1);
21654 0 : result = (int) ((arg1)->height);
21655 : resultobj = SWIG_From_int((int)(result));
21656 0 : return resultobj;
21657 0 : fail:
21658 : return NULL;
21659 : }
21660 :
21661 :
21662 0 : SWIGINTERN PyObject *_wrap_scalebarObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21663 : PyObject *resultobj = 0;
21664 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21665 : int arg2 ;
21666 0 : void *argp1 = 0 ;
21667 : int res1 = 0 ;
21668 : int val2 ;
21669 : int ecode2 = 0 ;
21670 0 : PyObject * obj0 = 0 ;
21671 0 : PyObject * obj1 = 0 ;
21672 :
21673 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_width_set",&obj0,&obj1)) SWIG_fail;
21674 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21675 0 : if (!SWIG_IsOK(res1)) {
21676 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_width_set" "', argument " "1"" of type '" "scalebarObj *""'");
21677 : }
21678 0 : arg1 = (scalebarObj *)(argp1);
21679 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21680 0 : if (!SWIG_IsOK(ecode2)) {
21681 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_width_set" "', argument " "2"" of type '" "int""'");
21682 : }
21683 : arg2 = (int)(val2);
21684 0 : if (arg1) (arg1)->width = arg2;
21685 : resultobj = SWIG_Py_Void();
21686 0 : return resultobj;
21687 0 : fail:
21688 : return NULL;
21689 : }
21690 :
21691 :
21692 0 : SWIGINTERN PyObject *_wrap_scalebarObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21693 : PyObject *resultobj = 0;
21694 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21695 0 : void *argp1 = 0 ;
21696 : int res1 = 0 ;
21697 0 : PyObject * obj0 = 0 ;
21698 : int result;
21699 :
21700 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_width_get",&obj0)) SWIG_fail;
21701 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21702 0 : if (!SWIG_IsOK(res1)) {
21703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_width_get" "', argument " "1"" of type '" "scalebarObj *""'");
21704 : }
21705 0 : arg1 = (scalebarObj *)(argp1);
21706 0 : result = (int) ((arg1)->width);
21707 : resultobj = SWIG_From_int((int)(result));
21708 0 : return resultobj;
21709 0 : fail:
21710 : return NULL;
21711 : }
21712 :
21713 :
21714 0 : SWIGINTERN PyObject *_wrap_scalebarObj_style_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21715 : PyObject *resultobj = 0;
21716 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21717 : int arg2 ;
21718 0 : void *argp1 = 0 ;
21719 : int res1 = 0 ;
21720 : int val2 ;
21721 : int ecode2 = 0 ;
21722 0 : PyObject * obj0 = 0 ;
21723 0 : PyObject * obj1 = 0 ;
21724 :
21725 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_style_set",&obj0,&obj1)) SWIG_fail;
21726 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21727 0 : if (!SWIG_IsOK(res1)) {
21728 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_style_set" "', argument " "1"" of type '" "scalebarObj *""'");
21729 : }
21730 0 : arg1 = (scalebarObj *)(argp1);
21731 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21732 0 : if (!SWIG_IsOK(ecode2)) {
21733 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_style_set" "', argument " "2"" of type '" "int""'");
21734 : }
21735 : arg2 = (int)(val2);
21736 0 : if (arg1) (arg1)->style = arg2;
21737 : resultobj = SWIG_Py_Void();
21738 0 : return resultobj;
21739 0 : fail:
21740 : return NULL;
21741 : }
21742 :
21743 :
21744 0 : SWIGINTERN PyObject *_wrap_scalebarObj_style_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21745 : PyObject *resultobj = 0;
21746 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21747 0 : void *argp1 = 0 ;
21748 : int res1 = 0 ;
21749 0 : PyObject * obj0 = 0 ;
21750 : int result;
21751 :
21752 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_style_get",&obj0)) SWIG_fail;
21753 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21754 0 : if (!SWIG_IsOK(res1)) {
21755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_style_get" "', argument " "1"" of type '" "scalebarObj *""'");
21756 : }
21757 0 : arg1 = (scalebarObj *)(argp1);
21758 0 : result = (int) ((arg1)->style);
21759 : resultobj = SWIG_From_int((int)(result));
21760 0 : return resultobj;
21761 0 : fail:
21762 : return NULL;
21763 : }
21764 :
21765 :
21766 0 : SWIGINTERN PyObject *_wrap_scalebarObj_intervals_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21767 : PyObject *resultobj = 0;
21768 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21769 : int arg2 ;
21770 0 : void *argp1 = 0 ;
21771 : int res1 = 0 ;
21772 : int val2 ;
21773 : int ecode2 = 0 ;
21774 0 : PyObject * obj0 = 0 ;
21775 0 : PyObject * obj1 = 0 ;
21776 :
21777 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_intervals_set",&obj0,&obj1)) SWIG_fail;
21778 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21779 0 : if (!SWIG_IsOK(res1)) {
21780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_intervals_set" "', argument " "1"" of type '" "scalebarObj *""'");
21781 : }
21782 0 : arg1 = (scalebarObj *)(argp1);
21783 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21784 0 : if (!SWIG_IsOK(ecode2)) {
21785 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_intervals_set" "', argument " "2"" of type '" "int""'");
21786 : }
21787 : arg2 = (int)(val2);
21788 0 : if (arg1) (arg1)->intervals = arg2;
21789 : resultobj = SWIG_Py_Void();
21790 0 : return resultobj;
21791 0 : fail:
21792 : return NULL;
21793 : }
21794 :
21795 :
21796 0 : SWIGINTERN PyObject *_wrap_scalebarObj_intervals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21797 : PyObject *resultobj = 0;
21798 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21799 0 : void *argp1 = 0 ;
21800 : int res1 = 0 ;
21801 0 : PyObject * obj0 = 0 ;
21802 : int result;
21803 :
21804 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_intervals_get",&obj0)) SWIG_fail;
21805 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21806 0 : if (!SWIG_IsOK(res1)) {
21807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_intervals_get" "', argument " "1"" of type '" "scalebarObj *""'");
21808 : }
21809 0 : arg1 = (scalebarObj *)(argp1);
21810 0 : result = (int) ((arg1)->intervals);
21811 : resultobj = SWIG_From_int((int)(result));
21812 0 : return resultobj;
21813 0 : fail:
21814 : return NULL;
21815 : }
21816 :
21817 :
21818 0 : SWIGINTERN PyObject *_wrap_scalebarObj_label_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21819 : PyObject *resultobj = 0;
21820 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21821 : labelObj *arg2 = (labelObj *) 0 ;
21822 0 : void *argp1 = 0 ;
21823 : int res1 = 0 ;
21824 0 : void *argp2 = 0 ;
21825 : int res2 = 0 ;
21826 0 : PyObject * obj0 = 0 ;
21827 0 : PyObject * obj1 = 0 ;
21828 :
21829 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_label_set",&obj0,&obj1)) SWIG_fail;
21830 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21831 0 : if (!SWIG_IsOK(res1)) {
21832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_label_set" "', argument " "1"" of type '" "scalebarObj *""'");
21833 : }
21834 0 : arg1 = (scalebarObj *)(argp1);
21835 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_labelObj, 0 | 0 );
21836 0 : if (!SWIG_IsOK(res2)) {
21837 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_label_set" "', argument " "2"" of type '" "labelObj *""'");
21838 : }
21839 0 : arg2 = (labelObj *)(argp2);
21840 0 : if (arg1) (arg1)->label = *arg2;
21841 : resultobj = SWIG_Py_Void();
21842 0 : return resultobj;
21843 0 : fail:
21844 : return NULL;
21845 : }
21846 :
21847 :
21848 0 : SWIGINTERN PyObject *_wrap_scalebarObj_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21849 : PyObject *resultobj = 0;
21850 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21851 0 : void *argp1 = 0 ;
21852 : int res1 = 0 ;
21853 0 : PyObject * obj0 = 0 ;
21854 : labelObj *result = 0 ;
21855 :
21856 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_label_get",&obj0)) SWIG_fail;
21857 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21858 0 : if (!SWIG_IsOK(res1)) {
21859 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_label_get" "', argument " "1"" of type '" "scalebarObj *""'");
21860 : }
21861 0 : arg1 = (scalebarObj *)(argp1);
21862 0 : result = (labelObj *)& ((arg1)->label);
21863 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, 0 | 0 );
21864 0 : return resultobj;
21865 0 : fail:
21866 : return NULL;
21867 : }
21868 :
21869 :
21870 0 : SWIGINTERN PyObject *_wrap_scalebarObj_color_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21871 : PyObject *resultobj = 0;
21872 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21873 : colorObj *arg2 = (colorObj *) 0 ;
21874 0 : void *argp1 = 0 ;
21875 : int res1 = 0 ;
21876 0 : void *argp2 = 0 ;
21877 : int res2 = 0 ;
21878 0 : PyObject * obj0 = 0 ;
21879 0 : PyObject * obj1 = 0 ;
21880 :
21881 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_color_set",&obj0,&obj1)) SWIG_fail;
21882 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21883 0 : if (!SWIG_IsOK(res1)) {
21884 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_color_set" "', argument " "1"" of type '" "scalebarObj *""'");
21885 : }
21886 0 : arg1 = (scalebarObj *)(argp1);
21887 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
21888 0 : if (!SWIG_IsOK(res2)) {
21889 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_color_set" "', argument " "2"" of type '" "colorObj *""'");
21890 : }
21891 0 : arg2 = (colorObj *)(argp2);
21892 0 : if (arg1) (arg1)->color = *arg2;
21893 : resultobj = SWIG_Py_Void();
21894 0 : return resultobj;
21895 0 : fail:
21896 : return NULL;
21897 : }
21898 :
21899 :
21900 0 : SWIGINTERN PyObject *_wrap_scalebarObj_color_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21901 : PyObject *resultobj = 0;
21902 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21903 0 : void *argp1 = 0 ;
21904 : int res1 = 0 ;
21905 0 : PyObject * obj0 = 0 ;
21906 : colorObj *result = 0 ;
21907 :
21908 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_color_get",&obj0)) SWIG_fail;
21909 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21910 0 : if (!SWIG_IsOK(res1)) {
21911 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_color_get" "', argument " "1"" of type '" "scalebarObj *""'");
21912 : }
21913 0 : arg1 = (scalebarObj *)(argp1);
21914 0 : result = (colorObj *)& ((arg1)->color);
21915 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
21916 0 : return resultobj;
21917 0 : fail:
21918 : return NULL;
21919 : }
21920 :
21921 :
21922 0 : SWIGINTERN PyObject *_wrap_scalebarObj_backgroundcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21923 : PyObject *resultobj = 0;
21924 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21925 : colorObj *arg2 = (colorObj *) 0 ;
21926 0 : void *argp1 = 0 ;
21927 : int res1 = 0 ;
21928 0 : void *argp2 = 0 ;
21929 : int res2 = 0 ;
21930 0 : PyObject * obj0 = 0 ;
21931 0 : PyObject * obj1 = 0 ;
21932 :
21933 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_backgroundcolor_set",&obj0,&obj1)) SWIG_fail;
21934 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21935 0 : if (!SWIG_IsOK(res1)) {
21936 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_backgroundcolor_set" "', argument " "1"" of type '" "scalebarObj *""'");
21937 : }
21938 0 : arg1 = (scalebarObj *)(argp1);
21939 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
21940 0 : if (!SWIG_IsOK(res2)) {
21941 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_backgroundcolor_set" "', argument " "2"" of type '" "colorObj *""'");
21942 : }
21943 0 : arg2 = (colorObj *)(argp2);
21944 0 : if (arg1) (arg1)->backgroundcolor = *arg2;
21945 : resultobj = SWIG_Py_Void();
21946 0 : return resultobj;
21947 0 : fail:
21948 : return NULL;
21949 : }
21950 :
21951 :
21952 0 : SWIGINTERN PyObject *_wrap_scalebarObj_backgroundcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21953 : PyObject *resultobj = 0;
21954 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21955 0 : void *argp1 = 0 ;
21956 : int res1 = 0 ;
21957 0 : PyObject * obj0 = 0 ;
21958 : colorObj *result = 0 ;
21959 :
21960 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_backgroundcolor_get",&obj0)) SWIG_fail;
21961 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21962 0 : if (!SWIG_IsOK(res1)) {
21963 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_backgroundcolor_get" "', argument " "1"" of type '" "scalebarObj *""'");
21964 : }
21965 0 : arg1 = (scalebarObj *)(argp1);
21966 0 : result = (colorObj *)& ((arg1)->backgroundcolor);
21967 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
21968 0 : return resultobj;
21969 0 : fail:
21970 : return NULL;
21971 : }
21972 :
21973 :
21974 0 : SWIGINTERN PyObject *_wrap_scalebarObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21975 : PyObject *resultobj = 0;
21976 : scalebarObj *arg1 = (scalebarObj *) 0 ;
21977 : colorObj *arg2 = (colorObj *) 0 ;
21978 0 : void *argp1 = 0 ;
21979 : int res1 = 0 ;
21980 0 : void *argp2 = 0 ;
21981 : int res2 = 0 ;
21982 0 : PyObject * obj0 = 0 ;
21983 0 : PyObject * obj1 = 0 ;
21984 :
21985 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
21986 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
21987 0 : if (!SWIG_IsOK(res1)) {
21988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_outlinecolor_set" "', argument " "1"" of type '" "scalebarObj *""'");
21989 : }
21990 0 : arg1 = (scalebarObj *)(argp1);
21991 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
21992 0 : if (!SWIG_IsOK(res2)) {
21993 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'");
21994 : }
21995 0 : arg2 = (colorObj *)(argp2);
21996 0 : if (arg1) (arg1)->outlinecolor = *arg2;
21997 : resultobj = SWIG_Py_Void();
21998 0 : return resultobj;
21999 0 : fail:
22000 : return NULL;
22001 : }
22002 :
22003 :
22004 0 : SWIGINTERN PyObject *_wrap_scalebarObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22005 : PyObject *resultobj = 0;
22006 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22007 0 : void *argp1 = 0 ;
22008 : int res1 = 0 ;
22009 0 : PyObject * obj0 = 0 ;
22010 : colorObj *result = 0 ;
22011 :
22012 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_outlinecolor_get",&obj0)) SWIG_fail;
22013 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22014 0 : if (!SWIG_IsOK(res1)) {
22015 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_outlinecolor_get" "', argument " "1"" of type '" "scalebarObj *""'");
22016 : }
22017 0 : arg1 = (scalebarObj *)(argp1);
22018 0 : result = (colorObj *)& ((arg1)->outlinecolor);
22019 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
22020 0 : return resultobj;
22021 0 : fail:
22022 : return NULL;
22023 : }
22024 :
22025 :
22026 0 : SWIGINTERN PyObject *_wrap_scalebarObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22027 : PyObject *resultobj = 0;
22028 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22029 : int arg2 ;
22030 0 : void *argp1 = 0 ;
22031 : int res1 = 0 ;
22032 : int val2 ;
22033 : int ecode2 = 0 ;
22034 0 : PyObject * obj0 = 0 ;
22035 0 : PyObject * obj1 = 0 ;
22036 :
22037 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_units_set",&obj0,&obj1)) SWIG_fail;
22038 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22039 0 : if (!SWIG_IsOK(res1)) {
22040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_units_set" "', argument " "1"" of type '" "scalebarObj *""'");
22041 : }
22042 0 : arg1 = (scalebarObj *)(argp1);
22043 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22044 0 : if (!SWIG_IsOK(ecode2)) {
22045 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_units_set" "', argument " "2"" of type '" "int""'");
22046 : }
22047 : arg2 = (int)(val2);
22048 0 : if (arg1) (arg1)->units = arg2;
22049 : resultobj = SWIG_Py_Void();
22050 0 : return resultobj;
22051 0 : fail:
22052 : return NULL;
22053 : }
22054 :
22055 :
22056 0 : SWIGINTERN PyObject *_wrap_scalebarObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22057 : PyObject *resultobj = 0;
22058 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22059 0 : void *argp1 = 0 ;
22060 : int res1 = 0 ;
22061 0 : PyObject * obj0 = 0 ;
22062 : int result;
22063 :
22064 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_units_get",&obj0)) SWIG_fail;
22065 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22066 0 : if (!SWIG_IsOK(res1)) {
22067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_units_get" "', argument " "1"" of type '" "scalebarObj *""'");
22068 : }
22069 0 : arg1 = (scalebarObj *)(argp1);
22070 0 : result = (int) ((arg1)->units);
22071 : resultobj = SWIG_From_int((int)(result));
22072 0 : return resultobj;
22073 0 : fail:
22074 : return NULL;
22075 : }
22076 :
22077 :
22078 0 : SWIGINTERN PyObject *_wrap_scalebarObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22079 : PyObject *resultobj = 0;
22080 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22081 : int arg2 ;
22082 0 : void *argp1 = 0 ;
22083 : int res1 = 0 ;
22084 : int val2 ;
22085 : int ecode2 = 0 ;
22086 0 : PyObject * obj0 = 0 ;
22087 0 : PyObject * obj1 = 0 ;
22088 :
22089 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_status_set",&obj0,&obj1)) SWIG_fail;
22090 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22091 0 : if (!SWIG_IsOK(res1)) {
22092 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_status_set" "', argument " "1"" of type '" "scalebarObj *""'");
22093 : }
22094 0 : arg1 = (scalebarObj *)(argp1);
22095 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22096 0 : if (!SWIG_IsOK(ecode2)) {
22097 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_status_set" "', argument " "2"" of type '" "int""'");
22098 : }
22099 : arg2 = (int)(val2);
22100 0 : if (arg1) (arg1)->status = arg2;
22101 : resultobj = SWIG_Py_Void();
22102 0 : return resultobj;
22103 0 : fail:
22104 : return NULL;
22105 : }
22106 :
22107 :
22108 0 : SWIGINTERN PyObject *_wrap_scalebarObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22109 : PyObject *resultobj = 0;
22110 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22111 0 : void *argp1 = 0 ;
22112 : int res1 = 0 ;
22113 0 : PyObject * obj0 = 0 ;
22114 : int result;
22115 :
22116 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_status_get",&obj0)) SWIG_fail;
22117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22118 0 : if (!SWIG_IsOK(res1)) {
22119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_status_get" "', argument " "1"" of type '" "scalebarObj *""'");
22120 : }
22121 0 : arg1 = (scalebarObj *)(argp1);
22122 0 : result = (int) ((arg1)->status);
22123 : resultobj = SWIG_From_int((int)(result));
22124 0 : return resultobj;
22125 0 : fail:
22126 : return NULL;
22127 : }
22128 :
22129 :
22130 0 : SWIGINTERN PyObject *_wrap_scalebarObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22131 : PyObject *resultobj = 0;
22132 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22133 : int arg2 ;
22134 0 : void *argp1 = 0 ;
22135 : int res1 = 0 ;
22136 : int val2 ;
22137 : int ecode2 = 0 ;
22138 0 : PyObject * obj0 = 0 ;
22139 0 : PyObject * obj1 = 0 ;
22140 :
22141 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_position_set",&obj0,&obj1)) SWIG_fail;
22142 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22143 0 : if (!SWIG_IsOK(res1)) {
22144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_position_set" "', argument " "1"" of type '" "scalebarObj *""'");
22145 : }
22146 0 : arg1 = (scalebarObj *)(argp1);
22147 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22148 0 : if (!SWIG_IsOK(ecode2)) {
22149 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_position_set" "', argument " "2"" of type '" "int""'");
22150 : }
22151 : arg2 = (int)(val2);
22152 0 : if (arg1) (arg1)->position = arg2;
22153 : resultobj = SWIG_Py_Void();
22154 0 : return resultobj;
22155 0 : fail:
22156 : return NULL;
22157 : }
22158 :
22159 :
22160 0 : SWIGINTERN PyObject *_wrap_scalebarObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22161 : PyObject *resultobj = 0;
22162 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22163 0 : void *argp1 = 0 ;
22164 : int res1 = 0 ;
22165 0 : PyObject * obj0 = 0 ;
22166 : int result;
22167 :
22168 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_position_get",&obj0)) SWIG_fail;
22169 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22170 0 : if (!SWIG_IsOK(res1)) {
22171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_position_get" "', argument " "1"" of type '" "scalebarObj *""'");
22172 : }
22173 0 : arg1 = (scalebarObj *)(argp1);
22174 0 : result = (int) ((arg1)->position);
22175 : resultobj = SWIG_From_int((int)(result));
22176 0 : return resultobj;
22177 0 : fail:
22178 : return NULL;
22179 : }
22180 :
22181 :
22182 0 : SWIGINTERN PyObject *_wrap_scalebarObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22183 : PyObject *resultobj = 0;
22184 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22185 : int arg2 ;
22186 0 : void *argp1 = 0 ;
22187 : int res1 = 0 ;
22188 : int val2 ;
22189 : int ecode2 = 0 ;
22190 0 : PyObject * obj0 = 0 ;
22191 0 : PyObject * obj1 = 0 ;
22192 :
22193 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
22194 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22195 0 : if (!SWIG_IsOK(res1)) {
22196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_postlabelcache_set" "', argument " "1"" of type '" "scalebarObj *""'");
22197 : }
22198 0 : arg1 = (scalebarObj *)(argp1);
22199 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22200 0 : if (!SWIG_IsOK(ecode2)) {
22201 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
22202 : }
22203 : arg2 = (int)(val2);
22204 0 : if (arg1) (arg1)->postlabelcache = arg2;
22205 : resultobj = SWIG_Py_Void();
22206 0 : return resultobj;
22207 0 : fail:
22208 : return NULL;
22209 : }
22210 :
22211 :
22212 0 : SWIGINTERN PyObject *_wrap_scalebarObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22213 : PyObject *resultobj = 0;
22214 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22215 0 : void *argp1 = 0 ;
22216 : int res1 = 0 ;
22217 0 : PyObject * obj0 = 0 ;
22218 : int result;
22219 :
22220 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_postlabelcache_get",&obj0)) SWIG_fail;
22221 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22222 0 : if (!SWIG_IsOK(res1)) {
22223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_postlabelcache_get" "', argument " "1"" of type '" "scalebarObj *""'");
22224 : }
22225 0 : arg1 = (scalebarObj *)(argp1);
22226 0 : result = (int) ((arg1)->postlabelcache);
22227 : resultobj = SWIG_From_int((int)(result));
22228 0 : return resultobj;
22229 0 : fail:
22230 : return NULL;
22231 : }
22232 :
22233 :
22234 0 : SWIGINTERN PyObject *_wrap_scalebarObj_align_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22235 : PyObject *resultobj = 0;
22236 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22237 : int arg2 ;
22238 0 : void *argp1 = 0 ;
22239 : int res1 = 0 ;
22240 : int val2 ;
22241 : int ecode2 = 0 ;
22242 0 : PyObject * obj0 = 0 ;
22243 0 : PyObject * obj1 = 0 ;
22244 :
22245 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_align_set",&obj0,&obj1)) SWIG_fail;
22246 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22247 0 : if (!SWIG_IsOK(res1)) {
22248 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_align_set" "', argument " "1"" of type '" "scalebarObj *""'");
22249 : }
22250 0 : arg1 = (scalebarObj *)(argp1);
22251 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22252 0 : if (!SWIG_IsOK(ecode2)) {
22253 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_align_set" "', argument " "2"" of type '" "int""'");
22254 : }
22255 : arg2 = (int)(val2);
22256 0 : if (arg1) (arg1)->align = arg2;
22257 : resultobj = SWIG_Py_Void();
22258 0 : return resultobj;
22259 0 : fail:
22260 : return NULL;
22261 : }
22262 :
22263 :
22264 0 : SWIGINTERN PyObject *_wrap_scalebarObj_align_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22265 : PyObject *resultobj = 0;
22266 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22267 0 : void *argp1 = 0 ;
22268 : int res1 = 0 ;
22269 0 : PyObject * obj0 = 0 ;
22270 : int result;
22271 :
22272 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_align_get",&obj0)) SWIG_fail;
22273 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22274 0 : if (!SWIG_IsOK(res1)) {
22275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_align_get" "', argument " "1"" of type '" "scalebarObj *""'");
22276 : }
22277 0 : arg1 = (scalebarObj *)(argp1);
22278 0 : result = (int) ((arg1)->align);
22279 : resultobj = SWIG_From_int((int)(result));
22280 0 : return resultobj;
22281 0 : fail:
22282 : return NULL;
22283 : }
22284 :
22285 :
22286 0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsetx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22287 : PyObject *resultobj = 0;
22288 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22289 : int arg2 ;
22290 0 : void *argp1 = 0 ;
22291 : int res1 = 0 ;
22292 : int val2 ;
22293 : int ecode2 = 0 ;
22294 0 : PyObject * obj0 = 0 ;
22295 0 : PyObject * obj1 = 0 ;
22296 :
22297 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_offsetx_set",&obj0,&obj1)) SWIG_fail;
22298 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22299 0 : if (!SWIG_IsOK(res1)) {
22300 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsetx_set" "', argument " "1"" of type '" "scalebarObj *""'");
22301 : }
22302 0 : arg1 = (scalebarObj *)(argp1);
22303 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22304 0 : if (!SWIG_IsOK(ecode2)) {
22305 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_offsetx_set" "', argument " "2"" of type '" "int""'");
22306 : }
22307 : arg2 = (int)(val2);
22308 0 : if (arg1) (arg1)->offsetx = arg2;
22309 : resultobj = SWIG_Py_Void();
22310 0 : return resultobj;
22311 0 : fail:
22312 : return NULL;
22313 : }
22314 :
22315 :
22316 0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsetx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22317 : PyObject *resultobj = 0;
22318 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22319 0 : void *argp1 = 0 ;
22320 : int res1 = 0 ;
22321 0 : PyObject * obj0 = 0 ;
22322 : int result;
22323 :
22324 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_offsetx_get",&obj0)) SWIG_fail;
22325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22326 0 : if (!SWIG_IsOK(res1)) {
22327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsetx_get" "', argument " "1"" of type '" "scalebarObj *""'");
22328 : }
22329 0 : arg1 = (scalebarObj *)(argp1);
22330 0 : result = (int) ((arg1)->offsetx);
22331 : resultobj = SWIG_From_int((int)(result));
22332 0 : return resultobj;
22333 0 : fail:
22334 : return NULL;
22335 : }
22336 :
22337 :
22338 0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsety_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22339 : PyObject *resultobj = 0;
22340 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22341 : int arg2 ;
22342 0 : void *argp1 = 0 ;
22343 : int res1 = 0 ;
22344 : int val2 ;
22345 : int ecode2 = 0 ;
22346 0 : PyObject * obj0 = 0 ;
22347 0 : PyObject * obj1 = 0 ;
22348 :
22349 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_offsety_set",&obj0,&obj1)) SWIG_fail;
22350 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22351 0 : if (!SWIG_IsOK(res1)) {
22352 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsety_set" "', argument " "1"" of type '" "scalebarObj *""'");
22353 : }
22354 0 : arg1 = (scalebarObj *)(argp1);
22355 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22356 0 : if (!SWIG_IsOK(ecode2)) {
22357 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scalebarObj_offsety_set" "', argument " "2"" of type '" "int""'");
22358 : }
22359 : arg2 = (int)(val2);
22360 0 : if (arg1) (arg1)->offsety = arg2;
22361 : resultobj = SWIG_Py_Void();
22362 0 : return resultobj;
22363 0 : fail:
22364 : return NULL;
22365 : }
22366 :
22367 :
22368 0 : SWIGINTERN PyObject *_wrap_scalebarObj_offsety_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22369 : PyObject *resultobj = 0;
22370 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22371 0 : void *argp1 = 0 ;
22372 : int res1 = 0 ;
22373 0 : PyObject * obj0 = 0 ;
22374 : int result;
22375 :
22376 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_offsety_get",&obj0)) SWIG_fail;
22377 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22378 0 : if (!SWIG_IsOK(res1)) {
22379 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_offsety_get" "', argument " "1"" of type '" "scalebarObj *""'");
22380 : }
22381 0 : arg1 = (scalebarObj *)(argp1);
22382 0 : result = (int) ((arg1)->offsety);
22383 : resultobj = SWIG_From_int((int)(result));
22384 0 : return resultobj;
22385 0 : fail:
22386 : return NULL;
22387 : }
22388 :
22389 :
22390 0 : SWIGINTERN PyObject *_wrap_scalebarObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 : PyObject *resultobj = 0;
22392 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22393 : char *arg2 = (char *) 0 ;
22394 0 : void *argp1 = 0 ;
22395 : int res1 = 0 ;
22396 : int res2 ;
22397 0 : char *buf2 = 0 ;
22398 0 : int alloc2 = 0 ;
22399 0 : PyObject * obj0 = 0 ;
22400 0 : PyObject * obj1 = 0 ;
22401 : int result;
22402 :
22403 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scalebarObj_updateFromString",&obj0,&obj1)) SWIG_fail;
22404 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22405 0 : if (!SWIG_IsOK(res1)) {
22406 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_updateFromString" "', argument " "1"" of type '" "scalebarObj *""'");
22407 : }
22408 0 : arg1 = (scalebarObj *)(argp1);
22409 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22410 0 : if (!SWIG_IsOK(res2)) {
22411 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scalebarObj_updateFromString" "', argument " "2"" of type '" "char *""'");
22412 : }
22413 0 : arg2 = (char *)(buf2);
22414 : {
22415 : result = (int)scalebarObj_updateFromString(arg1,arg2); {
22416 0 : errorObj *ms_error = msGetErrorObj();
22417 :
22418 0 : switch(ms_error->code) {
22419 : case MS_NOERR:
22420 : break;
22421 0 : case MS_NOTFOUND:
22422 0 : msResetErrorList();
22423 0 : break;
22424 : case -1:
22425 : break;
22426 0 : case MS_IOERR:
22427 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
22428 0 : _raise_ms_exception();
22429 0 : msResetErrorList();
22430 0 : return NULL;
22431 : }
22432 : default:
22433 0 : _raise_ms_exception();
22434 0 : msResetErrorList();
22435 0 : return NULL;
22436 : }
22437 :
22438 : }
22439 : }
22440 : resultobj = SWIG_From_int((int)(result));
22441 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22442 : return resultobj;
22443 0 : fail:
22444 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22445 : return NULL;
22446 : }
22447 :
22448 :
22449 0 : SWIGINTERN PyObject *_wrap_scalebarObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22450 : PyObject *resultobj = 0;
22451 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22452 0 : void *argp1 = 0 ;
22453 : int res1 = 0 ;
22454 0 : PyObject * obj0 = 0 ;
22455 : char *result = 0 ;
22456 :
22457 0 : if (!PyArg_ParseTuple(args,(char *)"O:scalebarObj_convertToString",&obj0)) SWIG_fail;
22458 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, 0 | 0 );
22459 0 : if (!SWIG_IsOK(res1)) {
22460 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scalebarObj_convertToString" "', argument " "1"" of type '" "scalebarObj *""'");
22461 : }
22462 0 : arg1 = (scalebarObj *)(argp1);
22463 : {
22464 : result = (char *)scalebarObj_convertToString(arg1); {
22465 0 : errorObj *ms_error = msGetErrorObj();
22466 :
22467 0 : switch(ms_error->code) {
22468 : case MS_NOERR:
22469 : break;
22470 0 : case MS_NOTFOUND:
22471 0 : msResetErrorList();
22472 0 : break;
22473 : case -1:
22474 : break;
22475 0 : case MS_IOERR:
22476 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
22477 0 : _raise_ms_exception();
22478 0 : msResetErrorList();
22479 0 : return NULL;
22480 : }
22481 : default:
22482 0 : _raise_ms_exception();
22483 0 : msResetErrorList();
22484 0 : return NULL;
22485 : }
22486 :
22487 : }
22488 : }
22489 0 : resultobj = SWIG_FromCharPtr((const char *)result);
22490 0 : free((char*)result);
22491 0 : return resultobj;
22492 0 : fail:
22493 : return NULL;
22494 : }
22495 :
22496 :
22497 0 : SWIGINTERN PyObject *_wrap_new_scalebarObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 : PyObject *resultobj = 0;
22499 : scalebarObj *result = 0 ;
22500 :
22501 0 : if (!PyArg_ParseTuple(args,(char *)":new_scalebarObj")) SWIG_fail;
22502 : {
22503 0 : result = (scalebarObj *)calloc(1, sizeof(scalebarObj)); {
22504 0 : errorObj *ms_error = msGetErrorObj();
22505 :
22506 0 : switch(ms_error->code) {
22507 : case MS_NOERR:
22508 : break;
22509 0 : case MS_NOTFOUND:
22510 0 : msResetErrorList();
22511 0 : break;
22512 : case -1:
22513 : break;
22514 0 : case MS_IOERR:
22515 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
22516 0 : _raise_ms_exception();
22517 0 : msResetErrorList();
22518 0 : return NULL;
22519 : }
22520 : default:
22521 0 : _raise_ms_exception();
22522 0 : msResetErrorList();
22523 0 : return NULL;
22524 : }
22525 :
22526 : }
22527 : }
22528 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scalebarObj, SWIG_POINTER_NEW | 0 );
22529 0 : return resultobj;
22530 0 : fail:
22531 : return NULL;
22532 : }
22533 :
22534 :
22535 0 : SWIGINTERN PyObject *_wrap_delete_scalebarObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22536 : PyObject *resultobj = 0;
22537 : scalebarObj *arg1 = (scalebarObj *) 0 ;
22538 0 : void *argp1 = 0 ;
22539 : int res1 = 0 ;
22540 0 : PyObject * obj0 = 0 ;
22541 :
22542 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_scalebarObj",&obj0)) SWIG_fail;
22543 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scalebarObj, SWIG_POINTER_DISOWN | 0 );
22544 0 : if (!SWIG_IsOK(res1)) {
22545 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scalebarObj" "', argument " "1"" of type '" "scalebarObj *""'");
22546 : }
22547 0 : arg1 = (scalebarObj *)(argp1);
22548 : {
22549 0 : free((char *) arg1); {
22550 0 : errorObj *ms_error = msGetErrorObj();
22551 :
22552 0 : switch(ms_error->code) {
22553 : case MS_NOERR:
22554 : break;
22555 0 : case MS_NOTFOUND:
22556 0 : msResetErrorList();
22557 0 : break;
22558 : case -1:
22559 : break;
22560 0 : case MS_IOERR:
22561 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
22562 0 : _raise_ms_exception();
22563 0 : msResetErrorList();
22564 0 : return NULL;
22565 : }
22566 : default:
22567 0 : _raise_ms_exception();
22568 0 : msResetErrorList();
22569 0 : return NULL;
22570 : }
22571 :
22572 : }
22573 : }
22574 : resultobj = SWIG_Py_Void();
22575 0 : return resultobj;
22576 0 : fail:
22577 : return NULL;
22578 : }
22579 :
22580 :
22581 1 : SWIGINTERN PyObject *scalebarObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22582 : PyObject *obj;
22583 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
22584 1 : SWIG_TypeNewClientData(SWIGTYPE_p_scalebarObj, SWIG_NewClientData(obj));
22585 1 : return SWIG_Py_Void();
22586 : }
22587 :
22588 0 : SWIGINTERN PyObject *_wrap_legendObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22589 : PyObject *resultobj = 0;
22590 : legendObj *arg1 = (legendObj *) 0 ;
22591 : colorObj *arg2 = (colorObj *) 0 ;
22592 0 : void *argp1 = 0 ;
22593 : int res1 = 0 ;
22594 0 : void *argp2 = 0 ;
22595 : int res2 = 0 ;
22596 0 : PyObject * obj0 = 0 ;
22597 0 : PyObject * obj1 = 0 ;
22598 :
22599 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
22600 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22601 0 : if (!SWIG_IsOK(res1)) {
22602 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_imagecolor_set" "', argument " "1"" of type '" "legendObj *""'");
22603 : }
22604 0 : arg1 = (legendObj *)(argp1);
22605 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
22606 0 : if (!SWIG_IsOK(res2)) {
22607 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'");
22608 : }
22609 0 : arg2 = (colorObj *)(argp2);
22610 0 : if (arg1) (arg1)->imagecolor = *arg2;
22611 : resultobj = SWIG_Py_Void();
22612 0 : return resultobj;
22613 0 : fail:
22614 : return NULL;
22615 : }
22616 :
22617 :
22618 0 : SWIGINTERN PyObject *_wrap_legendObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22619 : PyObject *resultobj = 0;
22620 : legendObj *arg1 = (legendObj *) 0 ;
22621 0 : void *argp1 = 0 ;
22622 : int res1 = 0 ;
22623 0 : PyObject * obj0 = 0 ;
22624 : colorObj *result = 0 ;
22625 :
22626 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_imagecolor_get",&obj0)) SWIG_fail;
22627 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22628 0 : if (!SWIG_IsOK(res1)) {
22629 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_imagecolor_get" "', argument " "1"" of type '" "legendObj *""'");
22630 : }
22631 0 : arg1 = (legendObj *)(argp1);
22632 0 : result = (colorObj *)& ((arg1)->imagecolor);
22633 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
22634 0 : return resultobj;
22635 0 : fail:
22636 : return NULL;
22637 : }
22638 :
22639 :
22640 0 : SWIGINTERN PyObject *_wrap_legendObj_label_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22641 : PyObject *resultobj = 0;
22642 : legendObj *arg1 = (legendObj *) 0 ;
22643 0 : void *argp1 = 0 ;
22644 : int res1 = 0 ;
22645 0 : PyObject * obj0 = 0 ;
22646 : labelObj *result = 0 ;
22647 :
22648 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_label_get",&obj0)) SWIG_fail;
22649 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22650 0 : if (!SWIG_IsOK(res1)) {
22651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_label_get" "', argument " "1"" of type '" "legendObj *""'");
22652 : }
22653 0 : arg1 = (legendObj *)(argp1);
22654 0 : result = (labelObj *)& ((arg1)->label);
22655 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelObj, 0 | 0 );
22656 0 : return resultobj;
22657 0 : fail:
22658 : return NULL;
22659 : }
22660 :
22661 :
22662 0 : SWIGINTERN PyObject *_wrap_legendObj_keysizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 : PyObject *resultobj = 0;
22664 : legendObj *arg1 = (legendObj *) 0 ;
22665 : int arg2 ;
22666 0 : void *argp1 = 0 ;
22667 : int res1 = 0 ;
22668 : int val2 ;
22669 : int ecode2 = 0 ;
22670 0 : PyObject * obj0 = 0 ;
22671 0 : PyObject * obj1 = 0 ;
22672 :
22673 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keysizex_set",&obj0,&obj1)) SWIG_fail;
22674 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22675 0 : if (!SWIG_IsOK(res1)) {
22676 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizex_set" "', argument " "1"" of type '" "legendObj *""'");
22677 : }
22678 0 : arg1 = (legendObj *)(argp1);
22679 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22680 0 : if (!SWIG_IsOK(ecode2)) {
22681 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keysizex_set" "', argument " "2"" of type '" "int""'");
22682 : }
22683 : arg2 = (int)(val2);
22684 0 : if (arg1) (arg1)->keysizex = arg2;
22685 : resultobj = SWIG_Py_Void();
22686 0 : return resultobj;
22687 0 : fail:
22688 : return NULL;
22689 : }
22690 :
22691 :
22692 0 : SWIGINTERN PyObject *_wrap_legendObj_keysizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 : PyObject *resultobj = 0;
22694 : legendObj *arg1 = (legendObj *) 0 ;
22695 0 : void *argp1 = 0 ;
22696 : int res1 = 0 ;
22697 0 : PyObject * obj0 = 0 ;
22698 : int result;
22699 :
22700 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keysizex_get",&obj0)) SWIG_fail;
22701 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22702 0 : if (!SWIG_IsOK(res1)) {
22703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizex_get" "', argument " "1"" of type '" "legendObj *""'");
22704 : }
22705 0 : arg1 = (legendObj *)(argp1);
22706 0 : result = (int) ((arg1)->keysizex);
22707 : resultobj = SWIG_From_int((int)(result));
22708 0 : return resultobj;
22709 0 : fail:
22710 : return NULL;
22711 : }
22712 :
22713 :
22714 0 : SWIGINTERN PyObject *_wrap_legendObj_keysizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 : PyObject *resultobj = 0;
22716 : legendObj *arg1 = (legendObj *) 0 ;
22717 : int arg2 ;
22718 0 : void *argp1 = 0 ;
22719 : int res1 = 0 ;
22720 : int val2 ;
22721 : int ecode2 = 0 ;
22722 0 : PyObject * obj0 = 0 ;
22723 0 : PyObject * obj1 = 0 ;
22724 :
22725 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keysizey_set",&obj0,&obj1)) SWIG_fail;
22726 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22727 0 : if (!SWIG_IsOK(res1)) {
22728 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizey_set" "', argument " "1"" of type '" "legendObj *""'");
22729 : }
22730 0 : arg1 = (legendObj *)(argp1);
22731 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22732 0 : if (!SWIG_IsOK(ecode2)) {
22733 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keysizey_set" "', argument " "2"" of type '" "int""'");
22734 : }
22735 : arg2 = (int)(val2);
22736 0 : if (arg1) (arg1)->keysizey = arg2;
22737 : resultobj = SWIG_Py_Void();
22738 0 : return resultobj;
22739 0 : fail:
22740 : return NULL;
22741 : }
22742 :
22743 :
22744 0 : SWIGINTERN PyObject *_wrap_legendObj_keysizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22745 : PyObject *resultobj = 0;
22746 : legendObj *arg1 = (legendObj *) 0 ;
22747 0 : void *argp1 = 0 ;
22748 : int res1 = 0 ;
22749 0 : PyObject * obj0 = 0 ;
22750 : int result;
22751 :
22752 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keysizey_get",&obj0)) SWIG_fail;
22753 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22754 0 : if (!SWIG_IsOK(res1)) {
22755 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keysizey_get" "', argument " "1"" of type '" "legendObj *""'");
22756 : }
22757 0 : arg1 = (legendObj *)(argp1);
22758 0 : result = (int) ((arg1)->keysizey);
22759 : resultobj = SWIG_From_int((int)(result));
22760 0 : return resultobj;
22761 0 : fail:
22762 : return NULL;
22763 : }
22764 :
22765 :
22766 0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22767 : PyObject *resultobj = 0;
22768 : legendObj *arg1 = (legendObj *) 0 ;
22769 : int arg2 ;
22770 0 : void *argp1 = 0 ;
22771 : int res1 = 0 ;
22772 : int val2 ;
22773 : int ecode2 = 0 ;
22774 0 : PyObject * obj0 = 0 ;
22775 0 : PyObject * obj1 = 0 ;
22776 :
22777 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keyspacingx_set",&obj0,&obj1)) SWIG_fail;
22778 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22779 0 : if (!SWIG_IsOK(res1)) {
22780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingx_set" "', argument " "1"" of type '" "legendObj *""'");
22781 : }
22782 0 : arg1 = (legendObj *)(argp1);
22783 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22784 0 : if (!SWIG_IsOK(ecode2)) {
22785 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keyspacingx_set" "', argument " "2"" of type '" "int""'");
22786 : }
22787 : arg2 = (int)(val2);
22788 0 : if (arg1) (arg1)->keyspacingx = arg2;
22789 : resultobj = SWIG_Py_Void();
22790 0 : return resultobj;
22791 0 : fail:
22792 : return NULL;
22793 : }
22794 :
22795 :
22796 0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22797 : PyObject *resultobj = 0;
22798 : legendObj *arg1 = (legendObj *) 0 ;
22799 0 : void *argp1 = 0 ;
22800 : int res1 = 0 ;
22801 0 : PyObject * obj0 = 0 ;
22802 : int result;
22803 :
22804 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keyspacingx_get",&obj0)) SWIG_fail;
22805 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22806 0 : if (!SWIG_IsOK(res1)) {
22807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingx_get" "', argument " "1"" of type '" "legendObj *""'");
22808 : }
22809 0 : arg1 = (legendObj *)(argp1);
22810 0 : result = (int) ((arg1)->keyspacingx);
22811 : resultobj = SWIG_From_int((int)(result));
22812 0 : return resultobj;
22813 0 : fail:
22814 : return NULL;
22815 : }
22816 :
22817 :
22818 0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22819 : PyObject *resultobj = 0;
22820 : legendObj *arg1 = (legendObj *) 0 ;
22821 : int arg2 ;
22822 0 : void *argp1 = 0 ;
22823 : int res1 = 0 ;
22824 : int val2 ;
22825 : int ecode2 = 0 ;
22826 0 : PyObject * obj0 = 0 ;
22827 0 : PyObject * obj1 = 0 ;
22828 :
22829 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_keyspacingy_set",&obj0,&obj1)) SWIG_fail;
22830 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22831 0 : if (!SWIG_IsOK(res1)) {
22832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingy_set" "', argument " "1"" of type '" "legendObj *""'");
22833 : }
22834 0 : arg1 = (legendObj *)(argp1);
22835 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22836 0 : if (!SWIG_IsOK(ecode2)) {
22837 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_keyspacingy_set" "', argument " "2"" of type '" "int""'");
22838 : }
22839 : arg2 = (int)(val2);
22840 0 : if (arg1) (arg1)->keyspacingy = arg2;
22841 : resultobj = SWIG_Py_Void();
22842 0 : return resultobj;
22843 0 : fail:
22844 : return NULL;
22845 : }
22846 :
22847 :
22848 0 : SWIGINTERN PyObject *_wrap_legendObj_keyspacingy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22849 : PyObject *resultobj = 0;
22850 : legendObj *arg1 = (legendObj *) 0 ;
22851 0 : void *argp1 = 0 ;
22852 : int res1 = 0 ;
22853 0 : PyObject * obj0 = 0 ;
22854 : int result;
22855 :
22856 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_keyspacingy_get",&obj0)) SWIG_fail;
22857 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22858 0 : if (!SWIG_IsOK(res1)) {
22859 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_keyspacingy_get" "', argument " "1"" of type '" "legendObj *""'");
22860 : }
22861 0 : arg1 = (legendObj *)(argp1);
22862 0 : result = (int) ((arg1)->keyspacingy);
22863 : resultobj = SWIG_From_int((int)(result));
22864 0 : return resultobj;
22865 0 : fail:
22866 : return NULL;
22867 : }
22868 :
22869 :
22870 0 : SWIGINTERN PyObject *_wrap_legendObj_outlinecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22871 : PyObject *resultobj = 0;
22872 : legendObj *arg1 = (legendObj *) 0 ;
22873 : colorObj *arg2 = (colorObj *) 0 ;
22874 0 : void *argp1 = 0 ;
22875 : int res1 = 0 ;
22876 0 : void *argp2 = 0 ;
22877 : int res2 = 0 ;
22878 0 : PyObject * obj0 = 0 ;
22879 0 : PyObject * obj1 = 0 ;
22880 :
22881 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_outlinecolor_set",&obj0,&obj1)) SWIG_fail;
22882 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22883 0 : if (!SWIG_IsOK(res1)) {
22884 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_outlinecolor_set" "', argument " "1"" of type '" "legendObj *""'");
22885 : }
22886 0 : arg1 = (legendObj *)(argp1);
22887 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
22888 0 : if (!SWIG_IsOK(res2)) {
22889 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_outlinecolor_set" "', argument " "2"" of type '" "colorObj *""'");
22890 : }
22891 0 : arg2 = (colorObj *)(argp2);
22892 0 : if (arg1) (arg1)->outlinecolor = *arg2;
22893 : resultobj = SWIG_Py_Void();
22894 0 : return resultobj;
22895 0 : fail:
22896 : return NULL;
22897 : }
22898 :
22899 :
22900 0 : SWIGINTERN PyObject *_wrap_legendObj_outlinecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22901 : PyObject *resultobj = 0;
22902 : legendObj *arg1 = (legendObj *) 0 ;
22903 0 : void *argp1 = 0 ;
22904 : int res1 = 0 ;
22905 0 : PyObject * obj0 = 0 ;
22906 : colorObj *result = 0 ;
22907 :
22908 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_outlinecolor_get",&obj0)) SWIG_fail;
22909 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22910 0 : if (!SWIG_IsOK(res1)) {
22911 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_outlinecolor_get" "', argument " "1"" of type '" "legendObj *""'");
22912 : }
22913 0 : arg1 = (legendObj *)(argp1);
22914 0 : result = (colorObj *)& ((arg1)->outlinecolor);
22915 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
22916 0 : return resultobj;
22917 0 : fail:
22918 : return NULL;
22919 : }
22920 :
22921 :
22922 0 : SWIGINTERN PyObject *_wrap_legendObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 : PyObject *resultobj = 0;
22924 : legendObj *arg1 = (legendObj *) 0 ;
22925 : int arg2 ;
22926 0 : void *argp1 = 0 ;
22927 : int res1 = 0 ;
22928 : int val2 ;
22929 : int ecode2 = 0 ;
22930 0 : PyObject * obj0 = 0 ;
22931 0 : PyObject * obj1 = 0 ;
22932 :
22933 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_status_set",&obj0,&obj1)) SWIG_fail;
22934 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22935 0 : if (!SWIG_IsOK(res1)) {
22936 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_status_set" "', argument " "1"" of type '" "legendObj *""'");
22937 : }
22938 0 : arg1 = (legendObj *)(argp1);
22939 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22940 0 : if (!SWIG_IsOK(ecode2)) {
22941 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_status_set" "', argument " "2"" of type '" "int""'");
22942 : }
22943 : arg2 = (int)(val2);
22944 0 : if (arg1) (arg1)->status = arg2;
22945 : resultobj = SWIG_Py_Void();
22946 0 : return resultobj;
22947 0 : fail:
22948 : return NULL;
22949 : }
22950 :
22951 :
22952 0 : SWIGINTERN PyObject *_wrap_legendObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22953 : PyObject *resultobj = 0;
22954 : legendObj *arg1 = (legendObj *) 0 ;
22955 0 : void *argp1 = 0 ;
22956 : int res1 = 0 ;
22957 0 : PyObject * obj0 = 0 ;
22958 : int result;
22959 :
22960 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_status_get",&obj0)) SWIG_fail;
22961 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22962 0 : if (!SWIG_IsOK(res1)) {
22963 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_status_get" "', argument " "1"" of type '" "legendObj *""'");
22964 : }
22965 0 : arg1 = (legendObj *)(argp1);
22966 0 : result = (int) ((arg1)->status);
22967 : resultobj = SWIG_From_int((int)(result));
22968 0 : return resultobj;
22969 0 : fail:
22970 : return NULL;
22971 : }
22972 :
22973 :
22974 0 : SWIGINTERN PyObject *_wrap_legendObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22975 : PyObject *resultobj = 0;
22976 : legendObj *arg1 = (legendObj *) 0 ;
22977 : int arg2 ;
22978 0 : void *argp1 = 0 ;
22979 : int res1 = 0 ;
22980 : int val2 ;
22981 : int ecode2 = 0 ;
22982 0 : PyObject * obj0 = 0 ;
22983 0 : PyObject * obj1 = 0 ;
22984 :
22985 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_height_set",&obj0,&obj1)) SWIG_fail;
22986 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
22987 0 : if (!SWIG_IsOK(res1)) {
22988 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_height_set" "', argument " "1"" of type '" "legendObj *""'");
22989 : }
22990 0 : arg1 = (legendObj *)(argp1);
22991 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22992 0 : if (!SWIG_IsOK(ecode2)) {
22993 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_height_set" "', argument " "2"" of type '" "int""'");
22994 : }
22995 : arg2 = (int)(val2);
22996 0 : if (arg1) (arg1)->height = arg2;
22997 : resultobj = SWIG_Py_Void();
22998 0 : return resultobj;
22999 0 : fail:
23000 : return NULL;
23001 : }
23002 :
23003 :
23004 0 : SWIGINTERN PyObject *_wrap_legendObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23005 : PyObject *resultobj = 0;
23006 : legendObj *arg1 = (legendObj *) 0 ;
23007 0 : void *argp1 = 0 ;
23008 : int res1 = 0 ;
23009 0 : PyObject * obj0 = 0 ;
23010 : int result;
23011 :
23012 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_height_get",&obj0)) SWIG_fail;
23013 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23014 0 : if (!SWIG_IsOK(res1)) {
23015 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_height_get" "', argument " "1"" of type '" "legendObj *""'");
23016 : }
23017 0 : arg1 = (legendObj *)(argp1);
23018 0 : result = (int) ((arg1)->height);
23019 : resultobj = SWIG_From_int((int)(result));
23020 0 : return resultobj;
23021 0 : fail:
23022 : return NULL;
23023 : }
23024 :
23025 :
23026 0 : SWIGINTERN PyObject *_wrap_legendObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23027 : PyObject *resultobj = 0;
23028 : legendObj *arg1 = (legendObj *) 0 ;
23029 : int arg2 ;
23030 0 : void *argp1 = 0 ;
23031 : int res1 = 0 ;
23032 : int val2 ;
23033 : int ecode2 = 0 ;
23034 0 : PyObject * obj0 = 0 ;
23035 0 : PyObject * obj1 = 0 ;
23036 :
23037 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_width_set",&obj0,&obj1)) SWIG_fail;
23038 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23039 0 : if (!SWIG_IsOK(res1)) {
23040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_width_set" "', argument " "1"" of type '" "legendObj *""'");
23041 : }
23042 0 : arg1 = (legendObj *)(argp1);
23043 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23044 0 : if (!SWIG_IsOK(ecode2)) {
23045 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_width_set" "', argument " "2"" of type '" "int""'");
23046 : }
23047 : arg2 = (int)(val2);
23048 0 : if (arg1) (arg1)->width = arg2;
23049 : resultobj = SWIG_Py_Void();
23050 0 : return resultobj;
23051 0 : fail:
23052 : return NULL;
23053 : }
23054 :
23055 :
23056 0 : SWIGINTERN PyObject *_wrap_legendObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23057 : PyObject *resultobj = 0;
23058 : legendObj *arg1 = (legendObj *) 0 ;
23059 0 : void *argp1 = 0 ;
23060 : int res1 = 0 ;
23061 0 : PyObject * obj0 = 0 ;
23062 : int result;
23063 :
23064 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_width_get",&obj0)) SWIG_fail;
23065 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23066 0 : if (!SWIG_IsOK(res1)) {
23067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_width_get" "', argument " "1"" of type '" "legendObj *""'");
23068 : }
23069 0 : arg1 = (legendObj *)(argp1);
23070 0 : result = (int) ((arg1)->width);
23071 : resultobj = SWIG_From_int((int)(result));
23072 0 : return resultobj;
23073 0 : fail:
23074 : return NULL;
23075 : }
23076 :
23077 :
23078 0 : SWIGINTERN PyObject *_wrap_legendObj_position_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23079 : PyObject *resultobj = 0;
23080 : legendObj *arg1 = (legendObj *) 0 ;
23081 : int arg2 ;
23082 0 : void *argp1 = 0 ;
23083 : int res1 = 0 ;
23084 : int val2 ;
23085 : int ecode2 = 0 ;
23086 0 : PyObject * obj0 = 0 ;
23087 0 : PyObject * obj1 = 0 ;
23088 :
23089 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_position_set",&obj0,&obj1)) SWIG_fail;
23090 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23091 0 : if (!SWIG_IsOK(res1)) {
23092 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_position_set" "', argument " "1"" of type '" "legendObj *""'");
23093 : }
23094 0 : arg1 = (legendObj *)(argp1);
23095 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23096 0 : if (!SWIG_IsOK(ecode2)) {
23097 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_position_set" "', argument " "2"" of type '" "int""'");
23098 : }
23099 : arg2 = (int)(val2);
23100 0 : if (arg1) (arg1)->position = arg2;
23101 : resultobj = SWIG_Py_Void();
23102 0 : return resultobj;
23103 0 : fail:
23104 : return NULL;
23105 : }
23106 :
23107 :
23108 0 : SWIGINTERN PyObject *_wrap_legendObj_position_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23109 : PyObject *resultobj = 0;
23110 : legendObj *arg1 = (legendObj *) 0 ;
23111 0 : void *argp1 = 0 ;
23112 : int res1 = 0 ;
23113 0 : PyObject * obj0 = 0 ;
23114 : int result;
23115 :
23116 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_position_get",&obj0)) SWIG_fail;
23117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23118 0 : if (!SWIG_IsOK(res1)) {
23119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_position_get" "', argument " "1"" of type '" "legendObj *""'");
23120 : }
23121 0 : arg1 = (legendObj *)(argp1);
23122 0 : result = (int) ((arg1)->position);
23123 : resultobj = SWIG_From_int((int)(result));
23124 0 : return resultobj;
23125 0 : fail:
23126 : return NULL;
23127 : }
23128 :
23129 :
23130 0 : SWIGINTERN PyObject *_wrap_legendObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23131 : PyObject *resultobj = 0;
23132 : legendObj *arg1 = (legendObj *) 0 ;
23133 : int arg2 ;
23134 0 : void *argp1 = 0 ;
23135 : int res1 = 0 ;
23136 : int val2 ;
23137 : int ecode2 = 0 ;
23138 0 : PyObject * obj0 = 0 ;
23139 0 : PyObject * obj1 = 0 ;
23140 :
23141 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
23142 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23143 0 : if (!SWIG_IsOK(res1)) {
23144 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_postlabelcache_set" "', argument " "1"" of type '" "legendObj *""'");
23145 : }
23146 0 : arg1 = (legendObj *)(argp1);
23147 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23148 0 : if (!SWIG_IsOK(ecode2)) {
23149 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "legendObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
23150 : }
23151 : arg2 = (int)(val2);
23152 0 : if (arg1) (arg1)->postlabelcache = arg2;
23153 : resultobj = SWIG_Py_Void();
23154 0 : return resultobj;
23155 0 : fail:
23156 : return NULL;
23157 : }
23158 :
23159 :
23160 0 : SWIGINTERN PyObject *_wrap_legendObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23161 : PyObject *resultobj = 0;
23162 : legendObj *arg1 = (legendObj *) 0 ;
23163 0 : void *argp1 = 0 ;
23164 : int res1 = 0 ;
23165 0 : PyObject * obj0 = 0 ;
23166 : int result;
23167 :
23168 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_postlabelcache_get",&obj0)) SWIG_fail;
23169 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23170 0 : if (!SWIG_IsOK(res1)) {
23171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_postlabelcache_get" "', argument " "1"" of type '" "legendObj *""'");
23172 : }
23173 0 : arg1 = (legendObj *)(argp1);
23174 0 : result = (int) ((arg1)->postlabelcache);
23175 : resultobj = SWIG_From_int((int)(result));
23176 0 : return resultobj;
23177 0 : fail:
23178 : return NULL;
23179 : }
23180 :
23181 :
23182 0 : SWIGINTERN PyObject *_wrap_legendObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23183 : PyObject *resultobj = 0;
23184 : legendObj *arg1 = (legendObj *) 0 ;
23185 : char *arg2 = (char *) 0 ;
23186 0 : void *argp1 = 0 ;
23187 : int res1 = 0 ;
23188 : int res2 ;
23189 0 : char *buf2 = 0 ;
23190 0 : int alloc2 = 0 ;
23191 0 : PyObject * obj0 = 0 ;
23192 0 : PyObject * obj1 = 0 ;
23193 :
23194 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_template_set",&obj0,&obj1)) SWIG_fail;
23195 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23196 0 : if (!SWIG_IsOK(res1)) {
23197 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_template_set" "', argument " "1"" of type '" "legendObj *""'");
23198 : }
23199 0 : arg1 = (legendObj *)(argp1);
23200 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23201 0 : if (!SWIG_IsOK(res2)) {
23202 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_template_set" "', argument " "2"" of type '" "char *""'");
23203 : }
23204 0 : arg2 = (char *)(buf2);
23205 : {
23206 0 : if (arg1->template) free((char*)arg1->template);
23207 0 : if (arg2) {
23208 0 : arg1->template = (char *) malloc(strlen(arg2)+1);
23209 : strcpy((char*)arg1->template,arg2);
23210 : } else {
23211 0 : arg1->template = 0;
23212 : }
23213 : }
23214 : resultobj = SWIG_Py_Void();
23215 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23216 : return resultobj;
23217 0 : fail:
23218 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23219 : return NULL;
23220 : }
23221 :
23222 :
23223 0 : SWIGINTERN PyObject *_wrap_legendObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23224 : PyObject *resultobj = 0;
23225 : legendObj *arg1 = (legendObj *) 0 ;
23226 0 : void *argp1 = 0 ;
23227 : int res1 = 0 ;
23228 0 : PyObject * obj0 = 0 ;
23229 : char *result = 0 ;
23230 :
23231 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_template_get",&obj0)) SWIG_fail;
23232 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23233 0 : if (!SWIG_IsOK(res1)) {
23234 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_template_get" "', argument " "1"" of type '" "legendObj *""'");
23235 : }
23236 0 : arg1 = (legendObj *)(argp1);
23237 0 : result = (char *) ((arg1)->template);
23238 0 : resultobj = SWIG_FromCharPtr((const char *)result);
23239 0 : return resultobj;
23240 0 : fail:
23241 : return NULL;
23242 : }
23243 :
23244 :
23245 0 : SWIGINTERN PyObject *_wrap_legendObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23246 : PyObject *resultobj = 0;
23247 : legendObj *arg1 = (legendObj *) 0 ;
23248 0 : void *argp1 = 0 ;
23249 : int res1 = 0 ;
23250 0 : PyObject * obj0 = 0 ;
23251 : struct mapObj *result = 0 ;
23252 :
23253 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_map_get",&obj0)) SWIG_fail;
23254 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23255 0 : if (!SWIG_IsOK(res1)) {
23256 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_map_get" "', argument " "1"" of type '" "legendObj *""'");
23257 : }
23258 0 : arg1 = (legendObj *)(argp1);
23259 0 : result = (struct mapObj *) ((arg1)->map);
23260 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 | 0 );
23261 0 : return resultobj;
23262 0 : fail:
23263 : return NULL;
23264 : }
23265 :
23266 :
23267 0 : SWIGINTERN PyObject *_wrap_legendObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23268 : PyObject *resultobj = 0;
23269 : legendObj *arg1 = (legendObj *) 0 ;
23270 : char *arg2 = (char *) 0 ;
23271 0 : void *argp1 = 0 ;
23272 : int res1 = 0 ;
23273 : int res2 ;
23274 0 : char *buf2 = 0 ;
23275 0 : int alloc2 = 0 ;
23276 0 : PyObject * obj0 = 0 ;
23277 0 : PyObject * obj1 = 0 ;
23278 : int result;
23279 :
23280 0 : if (!PyArg_ParseTuple(args,(char *)"OO:legendObj_updateFromString",&obj0,&obj1)) SWIG_fail;
23281 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23282 0 : if (!SWIG_IsOK(res1)) {
23283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_updateFromString" "', argument " "1"" of type '" "legendObj *""'");
23284 : }
23285 0 : arg1 = (legendObj *)(argp1);
23286 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23287 0 : if (!SWIG_IsOK(res2)) {
23288 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "legendObj_updateFromString" "', argument " "2"" of type '" "char *""'");
23289 : }
23290 0 : arg2 = (char *)(buf2);
23291 : {
23292 : result = (int)legendObj_updateFromString(arg1,arg2); {
23293 0 : errorObj *ms_error = msGetErrorObj();
23294 :
23295 0 : switch(ms_error->code) {
23296 : case MS_NOERR:
23297 : break;
23298 0 : case MS_NOTFOUND:
23299 0 : msResetErrorList();
23300 0 : break;
23301 : case -1:
23302 : break;
23303 0 : case MS_IOERR:
23304 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23305 0 : _raise_ms_exception();
23306 0 : msResetErrorList();
23307 0 : return NULL;
23308 : }
23309 : default:
23310 0 : _raise_ms_exception();
23311 0 : msResetErrorList();
23312 0 : return NULL;
23313 : }
23314 :
23315 : }
23316 : }
23317 : resultobj = SWIG_From_int((int)(result));
23318 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23319 : return resultobj;
23320 0 : fail:
23321 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23322 : return NULL;
23323 : }
23324 :
23325 :
23326 0 : SWIGINTERN PyObject *_wrap_legendObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23327 : PyObject *resultobj = 0;
23328 : legendObj *arg1 = (legendObj *) 0 ;
23329 0 : void *argp1 = 0 ;
23330 : int res1 = 0 ;
23331 0 : PyObject * obj0 = 0 ;
23332 : char *result = 0 ;
23333 :
23334 0 : if (!PyArg_ParseTuple(args,(char *)"O:legendObj_convertToString",&obj0)) SWIG_fail;
23335 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, 0 | 0 );
23336 0 : if (!SWIG_IsOK(res1)) {
23337 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "legendObj_convertToString" "', argument " "1"" of type '" "legendObj *""'");
23338 : }
23339 0 : arg1 = (legendObj *)(argp1);
23340 : {
23341 : result = (char *)legendObj_convertToString(arg1); {
23342 0 : errorObj *ms_error = msGetErrorObj();
23343 :
23344 0 : switch(ms_error->code) {
23345 : case MS_NOERR:
23346 : break;
23347 0 : case MS_NOTFOUND:
23348 0 : msResetErrorList();
23349 0 : break;
23350 : case -1:
23351 : break;
23352 0 : case MS_IOERR:
23353 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23354 0 : _raise_ms_exception();
23355 0 : msResetErrorList();
23356 0 : return NULL;
23357 : }
23358 : default:
23359 0 : _raise_ms_exception();
23360 0 : msResetErrorList();
23361 0 : return NULL;
23362 : }
23363 :
23364 : }
23365 : }
23366 0 : resultobj = SWIG_FromCharPtr((const char *)result);
23367 0 : free((char*)result);
23368 0 : return resultobj;
23369 0 : fail:
23370 : return NULL;
23371 : }
23372 :
23373 :
23374 0 : SWIGINTERN PyObject *_wrap_new_legendObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23375 : PyObject *resultobj = 0;
23376 : legendObj *result = 0 ;
23377 :
23378 0 : if (!PyArg_ParseTuple(args,(char *)":new_legendObj")) SWIG_fail;
23379 : {
23380 0 : result = (legendObj *)calloc(1, sizeof(legendObj)); {
23381 0 : errorObj *ms_error = msGetErrorObj();
23382 :
23383 0 : switch(ms_error->code) {
23384 : case MS_NOERR:
23385 : break;
23386 0 : case MS_NOTFOUND:
23387 0 : msResetErrorList();
23388 0 : break;
23389 : case -1:
23390 : break;
23391 0 : case MS_IOERR:
23392 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23393 0 : _raise_ms_exception();
23394 0 : msResetErrorList();
23395 0 : return NULL;
23396 : }
23397 : default:
23398 0 : _raise_ms_exception();
23399 0 : msResetErrorList();
23400 0 : return NULL;
23401 : }
23402 :
23403 : }
23404 : }
23405 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_legendObj, SWIG_POINTER_NEW | 0 );
23406 0 : return resultobj;
23407 0 : fail:
23408 : return NULL;
23409 : }
23410 :
23411 :
23412 0 : SWIGINTERN PyObject *_wrap_delete_legendObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23413 : PyObject *resultobj = 0;
23414 : legendObj *arg1 = (legendObj *) 0 ;
23415 0 : void *argp1 = 0 ;
23416 : int res1 = 0 ;
23417 0 : PyObject * obj0 = 0 ;
23418 :
23419 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_legendObj",&obj0)) SWIG_fail;
23420 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_legendObj, SWIG_POINTER_DISOWN | 0 );
23421 0 : if (!SWIG_IsOK(res1)) {
23422 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_legendObj" "', argument " "1"" of type '" "legendObj *""'");
23423 : }
23424 0 : arg1 = (legendObj *)(argp1);
23425 : {
23426 0 : free((char *) arg1); {
23427 0 : errorObj *ms_error = msGetErrorObj();
23428 :
23429 0 : switch(ms_error->code) {
23430 : case MS_NOERR:
23431 : break;
23432 0 : case MS_NOTFOUND:
23433 0 : msResetErrorList();
23434 0 : break;
23435 : case -1:
23436 : break;
23437 0 : case MS_IOERR:
23438 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23439 0 : _raise_ms_exception();
23440 0 : msResetErrorList();
23441 0 : return NULL;
23442 : }
23443 : default:
23444 0 : _raise_ms_exception();
23445 0 : msResetErrorList();
23446 0 : return NULL;
23447 : }
23448 :
23449 : }
23450 : }
23451 : resultobj = SWIG_Py_Void();
23452 0 : return resultobj;
23453 0 : fail:
23454 : return NULL;
23455 : }
23456 :
23457 :
23458 1 : SWIGINTERN PyObject *legendObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23459 : PyObject *obj;
23460 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
23461 1 : SWIG_TypeNewClientData(SWIGTYPE_p_legendObj, SWIG_NewClientData(obj));
23462 1 : return SWIG_Py_Void();
23463 : }
23464 :
23465 1 : SWIGINTERN PyObject *_wrap_imageObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23466 : PyObject *resultobj = 0;
23467 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23468 1 : void *argp1 = 0 ;
23469 : int res1 = 0 ;
23470 1 : PyObject * obj0 = 0 ;
23471 : int result;
23472 :
23473 1 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_width_get",&obj0)) SWIG_fail;
23474 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23475 1 : if (!SWIG_IsOK(res1)) {
23476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_width_get" "', argument " "1"" of type '" "struct imageObj *""'");
23477 : }
23478 1 : arg1 = (struct imageObj *)(argp1);
23479 1 : result = (int) ((arg1)->width);
23480 : resultobj = SWIG_From_int((int)(result));
23481 1 : return resultobj;
23482 0 : fail:
23483 : return NULL;
23484 : }
23485 :
23486 :
23487 1 : SWIGINTERN PyObject *_wrap_imageObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23488 : PyObject *resultobj = 0;
23489 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23490 1 : void *argp1 = 0 ;
23491 : int res1 = 0 ;
23492 1 : PyObject * obj0 = 0 ;
23493 : int result;
23494 :
23495 1 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_height_get",&obj0)) SWIG_fail;
23496 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23497 1 : if (!SWIG_IsOK(res1)) {
23498 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_height_get" "', argument " "1"" of type '" "struct imageObj *""'");
23499 : }
23500 1 : arg1 = (struct imageObj *)(argp1);
23501 1 : result = (int) ((arg1)->height);
23502 : resultobj = SWIG_From_int((int)(result));
23503 1 : return resultobj;
23504 0 : fail:
23505 : return NULL;
23506 : }
23507 :
23508 :
23509 0 : SWIGINTERN PyObject *_wrap_imageObj_resolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23510 : PyObject *resultobj = 0;
23511 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23512 0 : void *argp1 = 0 ;
23513 : int res1 = 0 ;
23514 0 : PyObject * obj0 = 0 ;
23515 : double result;
23516 :
23517 0 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_resolution_get",&obj0)) SWIG_fail;
23518 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23519 0 : if (!SWIG_IsOK(res1)) {
23520 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_resolution_get" "', argument " "1"" of type '" "struct imageObj *""'");
23521 : }
23522 0 : arg1 = (struct imageObj *)(argp1);
23523 0 : result = (double) ((arg1)->resolution);
23524 0 : resultobj = SWIG_From_double((double)(result));
23525 0 : return resultobj;
23526 0 : fail:
23527 : return NULL;
23528 : }
23529 :
23530 :
23531 0 : SWIGINTERN PyObject *_wrap_imageObj_resolutionfactor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23532 : PyObject *resultobj = 0;
23533 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23534 0 : void *argp1 = 0 ;
23535 : int res1 = 0 ;
23536 0 : PyObject * obj0 = 0 ;
23537 : double result;
23538 :
23539 0 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_resolutionfactor_get",&obj0)) SWIG_fail;
23540 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23541 0 : if (!SWIG_IsOK(res1)) {
23542 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_resolutionfactor_get" "', argument " "1"" of type '" "struct imageObj *""'");
23543 : }
23544 0 : arg1 = (struct imageObj *)(argp1);
23545 0 : result = (double) ((arg1)->resolutionfactor);
23546 0 : resultobj = SWIG_From_double((double)(result));
23547 0 : return resultobj;
23548 0 : fail:
23549 : return NULL;
23550 : }
23551 :
23552 :
23553 0 : SWIGINTERN PyObject *_wrap_imageObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23554 : PyObject *resultobj = 0;
23555 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23556 0 : void *argp1 = 0 ;
23557 : int res1 = 0 ;
23558 0 : PyObject * obj0 = 0 ;
23559 : char *result = 0 ;
23560 :
23561 0 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_imagepath_get",&obj0)) SWIG_fail;
23562 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23563 0 : if (!SWIG_IsOK(res1)) {
23564 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_imagepath_get" "', argument " "1"" of type '" "struct imageObj *""'");
23565 : }
23566 0 : arg1 = (struct imageObj *)(argp1);
23567 0 : result = (char *) ((arg1)->imagepath);
23568 0 : resultobj = SWIG_FromCharPtr((const char *)result);
23569 0 : return resultobj;
23570 0 : fail:
23571 : return NULL;
23572 : }
23573 :
23574 :
23575 0 : SWIGINTERN PyObject *_wrap_imageObj_imageurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23576 : PyObject *resultobj = 0;
23577 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23578 0 : void *argp1 = 0 ;
23579 : int res1 = 0 ;
23580 0 : PyObject * obj0 = 0 ;
23581 : char *result = 0 ;
23582 :
23583 0 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_imageurl_get",&obj0)) SWIG_fail;
23584 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23585 0 : if (!SWIG_IsOK(res1)) {
23586 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_imageurl_get" "', argument " "1"" of type '" "struct imageObj *""'");
23587 : }
23588 0 : arg1 = (struct imageObj *)(argp1);
23589 0 : result = (char *) ((arg1)->imageurl);
23590 0 : resultobj = SWIG_FromCharPtr((const char *)result);
23591 0 : return resultobj;
23592 0 : fail:
23593 : return NULL;
23594 : }
23595 :
23596 :
23597 1 : SWIGINTERN PyObject *_wrap_imageObj_format_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23598 : PyObject *resultobj = 0;
23599 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23600 1 : void *argp1 = 0 ;
23601 : int res1 = 0 ;
23602 1 : PyObject * obj0 = 0 ;
23603 : outputFormatObj *result = 0 ;
23604 :
23605 1 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_format_get",&obj0)) SWIG_fail;
23606 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23607 1 : if (!SWIG_IsOK(res1)) {
23608 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_format_get" "', argument " "1"" of type '" "struct imageObj *""'");
23609 : }
23610 1 : arg1 = (struct imageObj *)(argp1);
23611 1 : result = (outputFormatObj *) ((arg1)->format);
23612 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 | 0 );
23613 1 : return resultobj;
23614 0 : fail:
23615 : return NULL;
23616 : }
23617 :
23618 :
23619 1 : SWIGINTERN PyObject *_wrap_new_imageObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23620 : PyObject *resultobj = 0;
23621 : int arg1 ;
23622 : int arg2 ;
23623 : outputFormatObj *arg3 = (outputFormatObj *) NULL ;
23624 : char *arg4 = (char *) NULL ;
23625 : double arg5 = (double) MS_DEFAULT_RESOLUTION ;
23626 : double arg6 = (double) MS_DEFAULT_RESOLUTION ;
23627 : int val1 ;
23628 : int ecode1 = 0 ;
23629 : int val2 ;
23630 : int ecode2 = 0 ;
23631 1 : void *argp3 = 0 ;
23632 : int res3 = 0 ;
23633 : int res4 ;
23634 1 : char *buf4 = 0 ;
23635 1 : int alloc4 = 0 ;
23636 : double val5 ;
23637 : int ecode5 = 0 ;
23638 : double val6 ;
23639 : int ecode6 = 0 ;
23640 1 : PyObject * obj0 = 0 ;
23641 1 : PyObject * obj1 = 0 ;
23642 1 : PyObject * obj2 = 0 ;
23643 1 : PyObject * obj3 = 0 ;
23644 1 : PyObject * obj4 = 0 ;
23645 1 : PyObject * obj5 = 0 ;
23646 : struct imageObj *result = 0 ;
23647 :
23648 1 : if (!PyArg_ParseTuple(args,(char *)"OO|OOOO:new_imageObj",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
23649 1 : ecode1 = SWIG_AsVal_int(obj0, &val1);
23650 1 : if (!SWIG_IsOK(ecode1)) {
23651 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_imageObj" "', argument " "1"" of type '" "int""'");
23652 : }
23653 : arg1 = (int)(val1);
23654 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
23655 1 : if (!SWIG_IsOK(ecode2)) {
23656 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_imageObj" "', argument " "2"" of type '" "int""'");
23657 : }
23658 : arg2 = (int)(val2);
23659 1 : if (obj2) {
23660 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_outputFormatObj, 0 | 0 );
23661 1 : if (!SWIG_IsOK(res3)) {
23662 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_imageObj" "', argument " "3"" of type '" "outputFormatObj *""'");
23663 : }
23664 1 : arg3 = (outputFormatObj *)(argp3);
23665 : }
23666 1 : if (obj3) {
23667 0 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
23668 0 : if (!SWIG_IsOK(res4)) {
23669 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_imageObj" "', argument " "4"" of type '" "char const *""'");
23670 : }
23671 0 : arg4 = (char *)(buf4);
23672 : }
23673 1 : if (obj4) {
23674 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
23675 0 : if (!SWIG_IsOK(ecode5)) {
23676 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_imageObj" "', argument " "5"" of type '" "double""'");
23677 : }
23678 0 : arg5 = (double)(val5);
23679 : }
23680 1 : if (obj5) {
23681 0 : ecode6 = SWIG_AsVal_double(obj5, &val6);
23682 0 : if (!SWIG_IsOK(ecode6)) {
23683 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_imageObj" "', argument " "6"" of type '" "double""'");
23684 : }
23685 0 : arg6 = (double)(val6);
23686 : }
23687 : {
23688 1 : result = (struct imageObj *)new_imageObj(arg1,arg2,arg3,(char const *)arg4,arg5,arg6); {
23689 1 : errorObj *ms_error = msGetErrorObj();
23690 :
23691 1 : switch(ms_error->code) {
23692 : case MS_NOERR:
23693 : break;
23694 0 : case MS_NOTFOUND:
23695 0 : msResetErrorList();
23696 0 : break;
23697 : case -1:
23698 : break;
23699 0 : case MS_IOERR:
23700 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23701 0 : _raise_ms_exception();
23702 0 : msResetErrorList();
23703 0 : return NULL;
23704 : }
23705 : default:
23706 0 : _raise_ms_exception();
23707 0 : msResetErrorList();
23708 0 : return NULL;
23709 : }
23710 :
23711 : }
23712 : }
23713 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_NEW | 0 );
23714 1 : if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
23715 : return resultobj;
23716 0 : fail:
23717 0 : if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
23718 : return NULL;
23719 : }
23720 :
23721 :
23722 1 : SWIGINTERN PyObject *_wrap_delete_imageObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23723 : PyObject *resultobj = 0;
23724 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23725 1 : void *argp1 = 0 ;
23726 : int res1 = 0 ;
23727 1 : PyObject * obj0 = 0 ;
23728 :
23729 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_imageObj",&obj0)) SWIG_fail;
23730 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, SWIG_POINTER_DISOWN | 0 );
23731 1 : if (!SWIG_IsOK(res1)) {
23732 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_imageObj" "', argument " "1"" of type '" "struct imageObj *""'");
23733 : }
23734 1 : arg1 = (struct imageObj *)(argp1);
23735 : {
23736 : delete_imageObj(arg1); {
23737 1 : errorObj *ms_error = msGetErrorObj();
23738 :
23739 1 : switch(ms_error->code) {
23740 : case MS_NOERR:
23741 : break;
23742 0 : case MS_NOTFOUND:
23743 0 : msResetErrorList();
23744 0 : break;
23745 : case -1:
23746 : break;
23747 0 : case MS_IOERR:
23748 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23749 0 : _raise_ms_exception();
23750 0 : msResetErrorList();
23751 0 : return NULL;
23752 : }
23753 : default:
23754 0 : _raise_ms_exception();
23755 0 : msResetErrorList();
23756 0 : return NULL;
23757 : }
23758 :
23759 : }
23760 : }
23761 : resultobj = SWIG_Py_Void();
23762 1 : return resultobj;
23763 0 : fail:
23764 : return NULL;
23765 : }
23766 :
23767 :
23768 1 : SWIGINTERN PyObject *_wrap_imageObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23769 : PyObject *resultobj = 0;
23770 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23771 : char *arg2 = (char *) 0 ;
23772 : mapObj *arg3 = (mapObj *) NULL ;
23773 1 : void *argp1 = 0 ;
23774 : int res1 = 0 ;
23775 : int res2 ;
23776 1 : char *buf2 = 0 ;
23777 1 : int alloc2 = 0 ;
23778 1 : void *argp3 = 0 ;
23779 : int res3 = 0 ;
23780 1 : PyObject * obj0 = 0 ;
23781 1 : PyObject * obj1 = 0 ;
23782 1 : PyObject * obj2 = 0 ;
23783 :
23784 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:imageObj_save",&obj0,&obj1,&obj2)) SWIG_fail;
23785 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23786 1 : if (!SWIG_IsOK(res1)) {
23787 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_save" "', argument " "1"" of type '" "struct imageObj *""'");
23788 : }
23789 1 : arg1 = (struct imageObj *)(argp1);
23790 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
23791 1 : if (!SWIG_IsOK(res2)) {
23792 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "imageObj_save" "', argument " "2"" of type '" "char *""'");
23793 : }
23794 1 : arg2 = (char *)(buf2);
23795 1 : if (obj2) {
23796 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_mapObj, 0 | 0 );
23797 1 : if (!SWIG_IsOK(res3)) {
23798 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "imageObj_save" "', argument " "3"" of type '" "mapObj *""'");
23799 : }
23800 1 : arg3 = (mapObj *)(argp3);
23801 : }
23802 : {
23803 : imageObj_save(arg1,arg2,arg3); {
23804 1 : errorObj *ms_error = msGetErrorObj();
23805 :
23806 1 : switch(ms_error->code) {
23807 : case MS_NOERR:
23808 : break;
23809 0 : case MS_NOTFOUND:
23810 0 : msResetErrorList();
23811 0 : break;
23812 : case -1:
23813 : break;
23814 0 : case MS_IOERR:
23815 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23816 0 : _raise_ms_exception();
23817 0 : msResetErrorList();
23818 0 : return NULL;
23819 : }
23820 : default:
23821 0 : _raise_ms_exception();
23822 0 : msResetErrorList();
23823 0 : return NULL;
23824 : }
23825 :
23826 : }
23827 : }
23828 : resultobj = SWIG_Py_Void();
23829 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23830 : return resultobj;
23831 0 : fail:
23832 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
23833 : return NULL;
23834 : }
23835 :
23836 :
23837 1 : SWIGINTERN PyObject *_wrap_imageObj_getBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23838 : PyObject *resultobj = 0;
23839 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23840 1 : void *argp1 = 0 ;
23841 : int res1 = 0 ;
23842 1 : PyObject * obj0 = 0 ;
23843 : gdBuffer result;
23844 :
23845 1 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_getBytes",&obj0)) SWIG_fail;
23846 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23847 1 : if (!SWIG_IsOK(res1)) {
23848 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_getBytes" "', argument " "1"" of type '" "struct imageObj *""'");
23849 : }
23850 1 : arg1 = (struct imageObj *)(argp1);
23851 : {
23852 1 : result = imageObj_getBytes(arg1); {
23853 1 : errorObj *ms_error = msGetErrorObj();
23854 :
23855 1 : switch(ms_error->code) {
23856 : case MS_NOERR:
23857 : break;
23858 0 : case MS_NOTFOUND:
23859 0 : msResetErrorList();
23860 0 : break;
23861 : case -1:
23862 : break;
23863 0 : case MS_IOERR:
23864 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23865 0 : _raise_ms_exception();
23866 0 : msResetErrorList();
23867 0 : return NULL;
23868 : }
23869 : default:
23870 0 : _raise_ms_exception();
23871 0 : msResetErrorList();
23872 0 : return NULL;
23873 : }
23874 :
23875 : }
23876 : }
23877 : {
23878 1 : resultobj = PyBytes_FromStringAndSize((const char*)(&result)->data, (&result)->size);
23879 1 : if( (&result)->owns_data )
23880 1 : msFree((&result)->data);
23881 : }
23882 : return resultobj;
23883 0 : fail:
23884 : return NULL;
23885 : }
23886 :
23887 :
23888 0 : SWIGINTERN PyObject *_wrap_imageObj_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 : PyObject *resultobj = 0;
23890 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23891 0 : void *argp1 = 0 ;
23892 : int res1 = 0 ;
23893 0 : PyObject * obj0 = 0 ;
23894 : int result;
23895 :
23896 0 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_getSize",&obj0)) SWIG_fail;
23897 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23898 0 : if (!SWIG_IsOK(res1)) {
23899 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_getSize" "', argument " "1"" of type '" "struct imageObj *""'");
23900 : }
23901 0 : arg1 = (struct imageObj *)(argp1);
23902 : {
23903 0 : result = (int)imageObj_getSize(arg1); {
23904 0 : errorObj *ms_error = msGetErrorObj();
23905 :
23906 0 : switch(ms_error->code) {
23907 : case MS_NOERR:
23908 : break;
23909 0 : case MS_NOTFOUND:
23910 0 : msResetErrorList();
23911 0 : break;
23912 : case -1:
23913 : break;
23914 0 : case MS_IOERR:
23915 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23916 0 : _raise_ms_exception();
23917 0 : msResetErrorList();
23918 0 : return NULL;
23919 : }
23920 : default:
23921 0 : _raise_ms_exception();
23922 0 : msResetErrorList();
23923 0 : return NULL;
23924 : }
23925 :
23926 : }
23927 : }
23928 : resultobj = SWIG_From_int((int)(result));
23929 0 : return resultobj;
23930 0 : fail:
23931 : return NULL;
23932 : }
23933 :
23934 :
23935 1 : SWIGINTERN PyObject *_wrap_imageObj_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23936 : PyObject *resultobj = 0;
23937 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23938 : PyObject *arg2 = (PyObject *) Py_None ;
23939 1 : void *argp1 = 0 ;
23940 : int res1 = 0 ;
23941 1 : PyObject * obj0 = 0 ;
23942 1 : PyObject * obj1 = 0 ;
23943 : int result;
23944 :
23945 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:imageObj_write",&obj0,&obj1)) SWIG_fail;
23946 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23947 1 : if (!SWIG_IsOK(res1)) {
23948 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_write" "', argument " "1"" of type '" "struct imageObj *""'");
23949 : }
23950 1 : arg1 = (struct imageObj *)(argp1);
23951 1 : if (obj1) {
23952 : arg2 = obj1;
23953 : }
23954 : {
23955 1 : result = (int)imageObj_write(arg1,arg2); {
23956 1 : errorObj *ms_error = msGetErrorObj();
23957 :
23958 1 : switch(ms_error->code) {
23959 : case MS_NOERR:
23960 : break;
23961 0 : case MS_NOTFOUND:
23962 0 : msResetErrorList();
23963 0 : break;
23964 : case -1:
23965 : break;
23966 0 : case MS_IOERR:
23967 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
23968 0 : _raise_ms_exception();
23969 0 : msResetErrorList();
23970 0 : return NULL;
23971 : }
23972 : default:
23973 0 : _raise_ms_exception();
23974 0 : msResetErrorList();
23975 0 : return NULL;
23976 : }
23977 :
23978 : }
23979 : }
23980 : resultobj = SWIG_From_int((int)(result));
23981 1 : return resultobj;
23982 0 : fail:
23983 : return NULL;
23984 : }
23985 :
23986 :
23987 1 : SWIGINTERN PyObject *_wrap_imageObj_saveToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23988 : PyObject *resultobj = 0;
23989 : struct imageObj *arg1 = (struct imageObj *) 0 ;
23990 1 : void *argp1 = 0 ;
23991 : int res1 = 0 ;
23992 1 : PyObject * obj0 = 0 ;
23993 : PyObject *result = 0 ;
23994 :
23995 1 : if (!PyArg_ParseTuple(args,(char *)"O:imageObj_saveToString",&obj0)) SWIG_fail;
23996 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
23997 1 : if (!SWIG_IsOK(res1)) {
23998 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "imageObj_saveToString" "', argument " "1"" of type '" "struct imageObj *""'");
23999 : }
24000 1 : arg1 = (struct imageObj *)(argp1);
24001 : {
24002 1 : result = (PyObject *)imageObj_saveToString(arg1); {
24003 1 : errorObj *ms_error = msGetErrorObj();
24004 :
24005 1 : switch(ms_error->code) {
24006 : case MS_NOERR:
24007 : break;
24008 0 : case MS_NOTFOUND:
24009 0 : msResetErrorList();
24010 0 : break;
24011 : case -1:
24012 : break;
24013 0 : case MS_IOERR:
24014 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
24015 0 : _raise_ms_exception();
24016 0 : msResetErrorList();
24017 0 : return NULL;
24018 : }
24019 : default:
24020 0 : _raise_ms_exception();
24021 0 : msResetErrorList();
24022 0 : return NULL;
24023 : }
24024 :
24025 : }
24026 : }
24027 : resultobj = result;
24028 : return resultobj;
24029 0 : fail:
24030 : return NULL;
24031 : }
24032 :
24033 :
24034 1 : SWIGINTERN PyObject *imageObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24035 : PyObject *obj;
24036 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
24037 1 : SWIG_TypeNewClientData(SWIGTYPE_p_imageObj, SWIG_NewClientData(obj));
24038 1 : return SWIG_Py_Void();
24039 : }
24040 :
24041 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_minscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24042 : PyObject *resultobj = 0;
24043 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24044 : double arg2 ;
24045 0 : void *argp1 = 0 ;
24046 : int res1 = 0 ;
24047 : double val2 ;
24048 : int ecode2 = 0 ;
24049 0 : PyObject * obj0 = 0 ;
24050 0 : PyObject * obj1 = 0 ;
24051 :
24052 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_minscale_set",&obj0,&obj1)) SWIG_fail;
24053 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24054 0 : if (!SWIG_IsOK(res1)) {
24055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_minscale_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24056 : }
24057 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24058 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
24059 0 : if (!SWIG_IsOK(ecode2)) {
24060 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenEntryObj_minscale_set" "', argument " "2"" of type '" "double""'");
24061 : }
24062 0 : arg2 = (double)(val2);
24063 0 : if (arg1) (arg1)->minscale = arg2;
24064 : resultobj = SWIG_Py_Void();
24065 0 : return resultobj;
24066 0 : fail:
24067 : return NULL;
24068 : }
24069 :
24070 :
24071 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_minscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24072 : PyObject *resultobj = 0;
24073 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24074 0 : void *argp1 = 0 ;
24075 : int res1 = 0 ;
24076 0 : PyObject * obj0 = 0 ;
24077 : double result;
24078 :
24079 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_minscale_get",&obj0)) SWIG_fail;
24080 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24081 0 : if (!SWIG_IsOK(res1)) {
24082 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_minscale_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24083 : }
24084 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24085 0 : result = (double) ((arg1)->minscale);
24086 0 : resultobj = SWIG_From_double((double)(result));
24087 0 : return resultobj;
24088 0 : fail:
24089 : return NULL;
24090 : }
24091 :
24092 :
24093 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_maxscale_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24094 : PyObject *resultobj = 0;
24095 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24096 : double arg2 ;
24097 0 : void *argp1 = 0 ;
24098 : int res1 = 0 ;
24099 : double val2 ;
24100 : int ecode2 = 0 ;
24101 0 : PyObject * obj0 = 0 ;
24102 0 : PyObject * obj1 = 0 ;
24103 :
24104 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_maxscale_set",&obj0,&obj1)) SWIG_fail;
24105 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24106 0 : if (!SWIG_IsOK(res1)) {
24107 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_maxscale_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24108 : }
24109 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24110 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
24111 0 : if (!SWIG_IsOK(ecode2)) {
24112 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenEntryObj_maxscale_set" "', argument " "2"" of type '" "double""'");
24113 : }
24114 0 : arg2 = (double)(val2);
24115 0 : if (arg1) (arg1)->maxscale = arg2;
24116 : resultobj = SWIG_Py_Void();
24117 0 : return resultobj;
24118 0 : fail:
24119 : return NULL;
24120 : }
24121 :
24122 :
24123 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_maxscale_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24124 : PyObject *resultobj = 0;
24125 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24126 0 : void *argp1 = 0 ;
24127 : int res1 = 0 ;
24128 0 : PyObject * obj0 = 0 ;
24129 : double result;
24130 :
24131 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_maxscale_get",&obj0)) SWIG_fail;
24132 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24133 0 : if (!SWIG_IsOK(res1)) {
24134 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_maxscale_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24135 : }
24136 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24137 0 : result = (double) ((arg1)->maxscale);
24138 0 : resultobj = SWIG_From_double((double)(result));
24139 0 : return resultobj;
24140 0 : fail:
24141 : return NULL;
24142 : }
24143 :
24144 :
24145 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24146 : PyObject *resultobj = 0;
24147 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24148 : char *arg2 = (char *) 0 ;
24149 0 : void *argp1 = 0 ;
24150 : int res1 = 0 ;
24151 : int res2 ;
24152 0 : char *buf2 = 0 ;
24153 0 : int alloc2 = 0 ;
24154 0 : PyObject * obj0 = 0 ;
24155 0 : PyObject * obj1 = 0 ;
24156 :
24157 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenEntryObj_value_set",&obj0,&obj1)) SWIG_fail;
24158 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24159 0 : if (!SWIG_IsOK(res1)) {
24160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_value_set" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24161 : }
24162 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24163 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24164 0 : if (!SWIG_IsOK(res2)) {
24165 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenEntryObj_value_set" "', argument " "2"" of type '" "char *""'");
24166 : }
24167 0 : arg2 = (char *)(buf2);
24168 : {
24169 0 : if (arg1->value) free((char*)arg1->value);
24170 0 : if (arg2) {
24171 0 : arg1->value = (char *) malloc(strlen(arg2)+1);
24172 : strcpy((char*)arg1->value,arg2);
24173 : } else {
24174 0 : arg1->value = 0;
24175 : }
24176 : }
24177 : resultobj = SWIG_Py_Void();
24178 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24179 : return resultobj;
24180 0 : fail:
24181 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24182 : return NULL;
24183 : }
24184 :
24185 :
24186 0 : SWIGINTERN PyObject *_wrap_scaleTokenEntryObj_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24187 : PyObject *resultobj = 0;
24188 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24189 0 : void *argp1 = 0 ;
24190 : int res1 = 0 ;
24191 0 : PyObject * obj0 = 0 ;
24192 : char *result = 0 ;
24193 :
24194 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenEntryObj_value_get",&obj0)) SWIG_fail;
24195 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24196 0 : if (!SWIG_IsOK(res1)) {
24197 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenEntryObj_value_get" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24198 : }
24199 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24200 0 : result = (char *) ((arg1)->value);
24201 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24202 0 : return resultobj;
24203 0 : fail:
24204 : return NULL;
24205 : }
24206 :
24207 :
24208 0 : SWIGINTERN PyObject *_wrap_new_scaleTokenEntryObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24209 : PyObject *resultobj = 0;
24210 : scaleTokenEntryObj *result = 0 ;
24211 :
24212 0 : if (!PyArg_ParseTuple(args,(char *)":new_scaleTokenEntryObj")) SWIG_fail;
24213 : {
24214 0 : result = (scaleTokenEntryObj *)calloc(1, sizeof(scaleTokenEntryObj)); {
24215 0 : errorObj *ms_error = msGetErrorObj();
24216 :
24217 0 : switch(ms_error->code) {
24218 : case MS_NOERR:
24219 : break;
24220 0 : case MS_NOTFOUND:
24221 0 : msResetErrorList();
24222 0 : break;
24223 : case -1:
24224 : break;
24225 0 : case MS_IOERR:
24226 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
24227 0 : _raise_ms_exception();
24228 0 : msResetErrorList();
24229 0 : return NULL;
24230 : }
24231 : default:
24232 0 : _raise_ms_exception();
24233 0 : msResetErrorList();
24234 0 : return NULL;
24235 : }
24236 :
24237 : }
24238 : }
24239 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_NEW | 0 );
24240 0 : return resultobj;
24241 0 : fail:
24242 : return NULL;
24243 : }
24244 :
24245 :
24246 0 : SWIGINTERN PyObject *_wrap_delete_scaleTokenEntryObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24247 : PyObject *resultobj = 0;
24248 : scaleTokenEntryObj *arg1 = (scaleTokenEntryObj *) 0 ;
24249 0 : void *argp1 = 0 ;
24250 : int res1 = 0 ;
24251 0 : PyObject * obj0 = 0 ;
24252 :
24253 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_scaleTokenEntryObj",&obj0)) SWIG_fail;
24254 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_DISOWN | 0 );
24255 0 : if (!SWIG_IsOK(res1)) {
24256 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scaleTokenEntryObj" "', argument " "1"" of type '" "scaleTokenEntryObj *""'");
24257 : }
24258 0 : arg1 = (scaleTokenEntryObj *)(argp1);
24259 : {
24260 0 : free((char *) arg1); {
24261 0 : errorObj *ms_error = msGetErrorObj();
24262 :
24263 0 : switch(ms_error->code) {
24264 : case MS_NOERR:
24265 : break;
24266 0 : case MS_NOTFOUND:
24267 0 : msResetErrorList();
24268 0 : break;
24269 : case -1:
24270 : break;
24271 0 : case MS_IOERR:
24272 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
24273 0 : _raise_ms_exception();
24274 0 : msResetErrorList();
24275 0 : return NULL;
24276 : }
24277 : default:
24278 0 : _raise_ms_exception();
24279 0 : msResetErrorList();
24280 0 : return NULL;
24281 : }
24282 :
24283 : }
24284 : }
24285 : resultobj = SWIG_Py_Void();
24286 0 : return resultobj;
24287 0 : fail:
24288 : return NULL;
24289 : }
24290 :
24291 :
24292 1 : SWIGINTERN PyObject *scaleTokenEntryObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24293 : PyObject *obj;
24294 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
24295 1 : SWIG_TypeNewClientData(SWIGTYPE_p_scaleTokenEntryObj, SWIG_NewClientData(obj));
24296 1 : return SWIG_Py_Void();
24297 : }
24298 :
24299 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24300 : PyObject *resultobj = 0;
24301 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24302 : char *arg2 = (char *) 0 ;
24303 0 : void *argp1 = 0 ;
24304 : int res1 = 0 ;
24305 : int res2 ;
24306 0 : char *buf2 = 0 ;
24307 0 : int alloc2 = 0 ;
24308 0 : PyObject * obj0 = 0 ;
24309 0 : PyObject * obj1 = 0 ;
24310 :
24311 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_name_set",&obj0,&obj1)) SWIG_fail;
24312 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24313 0 : if (!SWIG_IsOK(res1)) {
24314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_name_set" "', argument " "1"" of type '" "scaleTokenObj *""'");
24315 : }
24316 0 : arg1 = (scaleTokenObj *)(argp1);
24317 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24318 0 : if (!SWIG_IsOK(res2)) {
24319 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenObj_name_set" "', argument " "2"" of type '" "char *""'");
24320 : }
24321 0 : arg2 = (char *)(buf2);
24322 : {
24323 0 : if (arg1->name) free((char*)arg1->name);
24324 0 : if (arg2) {
24325 0 : arg1->name = (char *) malloc(strlen(arg2)+1);
24326 : strcpy((char*)arg1->name,arg2);
24327 : } else {
24328 0 : arg1->name = 0;
24329 : }
24330 : }
24331 : resultobj = SWIG_Py_Void();
24332 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24333 : return resultobj;
24334 0 : fail:
24335 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24336 : return NULL;
24337 : }
24338 :
24339 :
24340 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24341 : PyObject *resultobj = 0;
24342 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24343 0 : void *argp1 = 0 ;
24344 : int res1 = 0 ;
24345 0 : PyObject * obj0 = 0 ;
24346 : char *result = 0 ;
24347 :
24348 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_name_get",&obj0)) SWIG_fail;
24349 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24350 0 : if (!SWIG_IsOK(res1)) {
24351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_name_get" "', argument " "1"" of type '" "scaleTokenObj *""'");
24352 : }
24353 0 : arg1 = (scaleTokenObj *)(argp1);
24354 0 : result = (char *) ((arg1)->name);
24355 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24356 0 : return resultobj;
24357 0 : fail:
24358 : return NULL;
24359 : }
24360 :
24361 :
24362 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_n_entries_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24363 : PyObject *resultobj = 0;
24364 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24365 : int arg2 ;
24366 0 : void *argp1 = 0 ;
24367 : int res1 = 0 ;
24368 : int val2 ;
24369 : int ecode2 = 0 ;
24370 0 : PyObject * obj0 = 0 ;
24371 0 : PyObject * obj1 = 0 ;
24372 :
24373 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_n_entries_set",&obj0,&obj1)) SWIG_fail;
24374 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24375 0 : if (!SWIG_IsOK(res1)) {
24376 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_n_entries_set" "', argument " "1"" of type '" "scaleTokenObj *""'");
24377 : }
24378 0 : arg1 = (scaleTokenObj *)(argp1);
24379 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24380 0 : if (!SWIG_IsOK(ecode2)) {
24381 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "scaleTokenObj_n_entries_set" "', argument " "2"" of type '" "int""'");
24382 : }
24383 : arg2 = (int)(val2);
24384 0 : if (arg1) (arg1)->n_entries = arg2;
24385 : resultobj = SWIG_Py_Void();
24386 0 : return resultobj;
24387 0 : fail:
24388 : return NULL;
24389 : }
24390 :
24391 :
24392 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_n_entries_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24393 : PyObject *resultobj = 0;
24394 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24395 0 : void *argp1 = 0 ;
24396 : int res1 = 0 ;
24397 0 : PyObject * obj0 = 0 ;
24398 : int result;
24399 :
24400 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_n_entries_get",&obj0)) SWIG_fail;
24401 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24402 0 : if (!SWIG_IsOK(res1)) {
24403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_n_entries_get" "', argument " "1"" of type '" "scaleTokenObj *""'");
24404 : }
24405 0 : arg1 = (scaleTokenObj *)(argp1);
24406 0 : result = (int) ((arg1)->n_entries);
24407 : resultobj = SWIG_From_int((int)(result));
24408 0 : return resultobj;
24409 0 : fail:
24410 : return NULL;
24411 : }
24412 :
24413 :
24414 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_tokens_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24415 : PyObject *resultobj = 0;
24416 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24417 : scaleTokenEntryObj *arg2 = (scaleTokenEntryObj *) 0 ;
24418 0 : void *argp1 = 0 ;
24419 : int res1 = 0 ;
24420 0 : void *argp2 = 0 ;
24421 : int res2 = 0 ;
24422 0 : PyObject * obj0 = 0 ;
24423 0 : PyObject * obj1 = 0 ;
24424 :
24425 0 : if (!PyArg_ParseTuple(args,(char *)"OO:scaleTokenObj_tokens_set",&obj0,&obj1)) SWIG_fail;
24426 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24427 0 : if (!SWIG_IsOK(res1)) {
24428 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_tokens_set" "', argument " "1"" of type '" "scaleTokenObj *""'");
24429 : }
24430 0 : arg1 = (scaleTokenObj *)(argp1);
24431 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_scaleTokenEntryObj, SWIG_POINTER_DISOWN | 0 );
24432 0 : if (!SWIG_IsOK(res2)) {
24433 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "scaleTokenObj_tokens_set" "', argument " "2"" of type '" "scaleTokenEntryObj *""'");
24434 : }
24435 0 : arg2 = (scaleTokenEntryObj *)(argp2);
24436 0 : if (arg1) (arg1)->tokens = arg2;
24437 : resultobj = SWIG_Py_Void();
24438 0 : return resultobj;
24439 0 : fail:
24440 : return NULL;
24441 : }
24442 :
24443 :
24444 0 : SWIGINTERN PyObject *_wrap_scaleTokenObj_tokens_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24445 : PyObject *resultobj = 0;
24446 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24447 0 : void *argp1 = 0 ;
24448 : int res1 = 0 ;
24449 0 : PyObject * obj0 = 0 ;
24450 : scaleTokenEntryObj *result = 0 ;
24451 :
24452 0 : if (!PyArg_ParseTuple(args,(char *)"O:scaleTokenObj_tokens_get",&obj0)) SWIG_fail;
24453 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, 0 | 0 );
24454 0 : if (!SWIG_IsOK(res1)) {
24455 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "scaleTokenObj_tokens_get" "', argument " "1"" of type '" "scaleTokenObj *""'");
24456 : }
24457 0 : arg1 = (scaleTokenObj *)(argp1);
24458 0 : result = (scaleTokenEntryObj *) ((arg1)->tokens);
24459 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenEntryObj, 0 | 0 );
24460 0 : return resultobj;
24461 0 : fail:
24462 : return NULL;
24463 : }
24464 :
24465 :
24466 0 : SWIGINTERN PyObject *_wrap_new_scaleTokenObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24467 : PyObject *resultobj = 0;
24468 : scaleTokenObj *result = 0 ;
24469 :
24470 0 : if (!PyArg_ParseTuple(args,(char *)":new_scaleTokenObj")) SWIG_fail;
24471 : {
24472 0 : result = (scaleTokenObj *)calloc(1, sizeof(scaleTokenObj)); {
24473 0 : errorObj *ms_error = msGetErrorObj();
24474 :
24475 0 : switch(ms_error->code) {
24476 : case MS_NOERR:
24477 : break;
24478 0 : case MS_NOTFOUND:
24479 0 : msResetErrorList();
24480 0 : break;
24481 : case -1:
24482 : break;
24483 0 : case MS_IOERR:
24484 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
24485 0 : _raise_ms_exception();
24486 0 : msResetErrorList();
24487 0 : return NULL;
24488 : }
24489 : default:
24490 0 : _raise_ms_exception();
24491 0 : msResetErrorList();
24492 0 : return NULL;
24493 : }
24494 :
24495 : }
24496 : }
24497 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scaleTokenObj, SWIG_POINTER_NEW | 0 );
24498 0 : return resultobj;
24499 0 : fail:
24500 : return NULL;
24501 : }
24502 :
24503 :
24504 0 : SWIGINTERN PyObject *_wrap_delete_scaleTokenObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24505 : PyObject *resultobj = 0;
24506 : scaleTokenObj *arg1 = (scaleTokenObj *) 0 ;
24507 0 : void *argp1 = 0 ;
24508 : int res1 = 0 ;
24509 0 : PyObject * obj0 = 0 ;
24510 :
24511 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_scaleTokenObj",&obj0)) SWIG_fail;
24512 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_scaleTokenObj, SWIG_POINTER_DISOWN | 0 );
24513 0 : if (!SWIG_IsOK(res1)) {
24514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_scaleTokenObj" "', argument " "1"" of type '" "scaleTokenObj *""'");
24515 : }
24516 0 : arg1 = (scaleTokenObj *)(argp1);
24517 : {
24518 0 : free((char *) arg1); {
24519 0 : errorObj *ms_error = msGetErrorObj();
24520 :
24521 0 : switch(ms_error->code) {
24522 : case MS_NOERR:
24523 : break;
24524 0 : case MS_NOTFOUND:
24525 0 : msResetErrorList();
24526 0 : break;
24527 : case -1:
24528 : break;
24529 0 : case MS_IOERR:
24530 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
24531 0 : _raise_ms_exception();
24532 0 : msResetErrorList();
24533 0 : return NULL;
24534 : }
24535 : default:
24536 0 : _raise_ms_exception();
24537 0 : msResetErrorList();
24538 0 : return NULL;
24539 : }
24540 :
24541 : }
24542 : }
24543 : resultobj = SWIG_Py_Void();
24544 0 : return resultobj;
24545 0 : fail:
24546 : return NULL;
24547 : }
24548 :
24549 :
24550 1 : SWIGINTERN PyObject *scaleTokenObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24551 : PyObject *obj;
24552 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
24553 1 : SWIG_TypeNewClientData(SWIGTYPE_p_scaleTokenObj, SWIG_NewClientData(obj));
24554 1 : return SWIG_Py_Void();
24555 : }
24556 :
24557 0 : SWIGINTERN PyObject *_wrap_layerObj_classitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24558 : PyObject *resultobj = 0;
24559 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24560 : char *arg2 = (char *) 0 ;
24561 0 : void *argp1 = 0 ;
24562 : int res1 = 0 ;
24563 : int res2 ;
24564 0 : char *buf2 = 0 ;
24565 0 : int alloc2 = 0 ;
24566 0 : PyObject * obj0 = 0 ;
24567 0 : PyObject * obj1 = 0 ;
24568 :
24569 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_classitem_set",&obj0,&obj1)) SWIG_fail;
24570 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24571 0 : if (!SWIG_IsOK(res1)) {
24572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
24573 : }
24574 0 : arg1 = (struct layerObj *)(argp1);
24575 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24576 0 : if (!SWIG_IsOK(res2)) {
24577 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_classitem_set" "', argument " "2"" of type '" "char *""'");
24578 : }
24579 0 : arg2 = (char *)(buf2);
24580 : {
24581 0 : if (arg1->classitem) free((char*)arg1->classitem);
24582 0 : if (arg2) {
24583 0 : arg1->classitem = (char *) malloc(strlen(arg2)+1);
24584 : strcpy((char*)arg1->classitem,arg2);
24585 : } else {
24586 0 : arg1->classitem = 0;
24587 : }
24588 : }
24589 : resultobj = SWIG_Py_Void();
24590 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24591 : return resultobj;
24592 0 : fail:
24593 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24594 : return NULL;
24595 : }
24596 :
24597 :
24598 0 : SWIGINTERN PyObject *_wrap_layerObj_classitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 : PyObject *resultobj = 0;
24600 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24601 0 : void *argp1 = 0 ;
24602 : int res1 = 0 ;
24603 0 : PyObject * obj0 = 0 ;
24604 : char *result = 0 ;
24605 :
24606 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_classitem_get",&obj0)) SWIG_fail;
24607 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24608 0 : if (!SWIG_IsOK(res1)) {
24609 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
24610 : }
24611 0 : arg1 = (struct layerObj *)(argp1);
24612 0 : result = (char *) ((arg1)->classitem);
24613 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24614 0 : return resultobj;
24615 0 : fail:
24616 : return NULL;
24617 : }
24618 :
24619 :
24620 1 : SWIGINTERN PyObject *_wrap_layerObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24621 : PyObject *resultobj = 0;
24622 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24623 1 : void *argp1 = 0 ;
24624 : int res1 = 0 ;
24625 1 : PyObject * obj0 = 0 ;
24626 : int result;
24627 :
24628 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_refcount_get",&obj0)) SWIG_fail;
24629 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24630 1 : if (!SWIG_IsOK(res1)) {
24631 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_refcount_get" "', argument " "1"" of type '" "struct layerObj *""'");
24632 : }
24633 1 : arg1 = (struct layerObj *)(argp1);
24634 1 : result = (int) ((arg1)->refcount);
24635 : resultobj = SWIG_From_int((int)(result));
24636 1 : return resultobj;
24637 0 : fail:
24638 : return NULL;
24639 : }
24640 :
24641 :
24642 1 : SWIGINTERN PyObject *_wrap_layerObj_numclasses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24643 : PyObject *resultobj = 0;
24644 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24645 1 : void *argp1 = 0 ;
24646 : int res1 = 0 ;
24647 1 : PyObject * obj0 = 0 ;
24648 : int result;
24649 :
24650 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numclasses_get",&obj0)) SWIG_fail;
24651 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24652 1 : if (!SWIG_IsOK(res1)) {
24653 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numclasses_get" "', argument " "1"" of type '" "struct layerObj *""'");
24654 : }
24655 1 : arg1 = (struct layerObj *)(argp1);
24656 1 : result = (int) ((arg1)->numclasses);
24657 : resultobj = SWIG_From_int((int)(result));
24658 1 : return resultobj;
24659 0 : fail:
24660 : return NULL;
24661 : }
24662 :
24663 :
24664 0 : SWIGINTERN PyObject *_wrap_layerObj_maxclasses_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24665 : PyObject *resultobj = 0;
24666 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24667 0 : void *argp1 = 0 ;
24668 : int res1 = 0 ;
24669 0 : PyObject * obj0 = 0 ;
24670 : int result;
24671 :
24672 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxclasses_get",&obj0)) SWIG_fail;
24673 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24674 0 : if (!SWIG_IsOK(res1)) {
24675 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxclasses_get" "', argument " "1"" of type '" "struct layerObj *""'");
24676 : }
24677 0 : arg1 = (struct layerObj *)(argp1);
24678 0 : result = (int) ((arg1)->maxclasses);
24679 : resultobj = SWIG_From_int((int)(result));
24680 0 : return resultobj;
24681 0 : fail:
24682 : return NULL;
24683 : }
24684 :
24685 :
24686 1 : SWIGINTERN PyObject *_wrap_layerObj_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24687 : PyObject *resultobj = 0;
24688 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24689 1 : void *argp1 = 0 ;
24690 : int res1 = 0 ;
24691 1 : PyObject * obj0 = 0 ;
24692 : int result;
24693 :
24694 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_index_get",&obj0)) SWIG_fail;
24695 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24696 1 : if (!SWIG_IsOK(res1)) {
24697 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_index_get" "', argument " "1"" of type '" "struct layerObj *""'");
24698 : }
24699 1 : arg1 = (struct layerObj *)(argp1);
24700 1 : result = (int) ((arg1)->index);
24701 : resultobj = SWIG_From_int((int)(result));
24702 1 : return resultobj;
24703 0 : fail:
24704 : return NULL;
24705 : }
24706 :
24707 :
24708 1 : SWIGINTERN PyObject *_wrap_layerObj_map_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24709 : PyObject *resultobj = 0;
24710 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24711 1 : void *argp1 = 0 ;
24712 : int res1 = 0 ;
24713 1 : PyObject * obj0 = 0 ;
24714 : struct mapObj *result = 0 ;
24715 :
24716 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_map_get",&obj0)) SWIG_fail;
24717 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24718 1 : if (!SWIG_IsOK(res1)) {
24719 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_map_get" "', argument " "1"" of type '" "struct layerObj *""'");
24720 : }
24721 1 : arg1 = (struct layerObj *)(argp1);
24722 1 : result = (struct mapObj *) ((arg1)->map);
24723 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, 0 | 0 );
24724 1 : return resultobj;
24725 0 : fail:
24726 : return NULL;
24727 : }
24728 :
24729 :
24730 0 : SWIGINTERN PyObject *_wrap_layerObj_header_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24731 : PyObject *resultobj = 0;
24732 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24733 : char *arg2 = (char *) 0 ;
24734 0 : void *argp1 = 0 ;
24735 : int res1 = 0 ;
24736 : int res2 ;
24737 0 : char *buf2 = 0 ;
24738 0 : int alloc2 = 0 ;
24739 0 : PyObject * obj0 = 0 ;
24740 0 : PyObject * obj1 = 0 ;
24741 :
24742 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_header_set",&obj0,&obj1)) SWIG_fail;
24743 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24744 0 : if (!SWIG_IsOK(res1)) {
24745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_header_set" "', argument " "1"" of type '" "struct layerObj *""'");
24746 : }
24747 0 : arg1 = (struct layerObj *)(argp1);
24748 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24749 0 : if (!SWIG_IsOK(res2)) {
24750 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_header_set" "', argument " "2"" of type '" "char *""'");
24751 : }
24752 0 : arg2 = (char *)(buf2);
24753 : {
24754 0 : if (arg1->header) free((char*)arg1->header);
24755 0 : if (arg2) {
24756 0 : arg1->header = (char *) malloc(strlen(arg2)+1);
24757 : strcpy((char*)arg1->header,arg2);
24758 : } else {
24759 0 : arg1->header = 0;
24760 : }
24761 : }
24762 : resultobj = SWIG_Py_Void();
24763 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24764 : return resultobj;
24765 0 : fail:
24766 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24767 : return NULL;
24768 : }
24769 :
24770 :
24771 0 : SWIGINTERN PyObject *_wrap_layerObj_header_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24772 : PyObject *resultobj = 0;
24773 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24774 0 : void *argp1 = 0 ;
24775 : int res1 = 0 ;
24776 0 : PyObject * obj0 = 0 ;
24777 : char *result = 0 ;
24778 :
24779 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_header_get",&obj0)) SWIG_fail;
24780 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24781 0 : if (!SWIG_IsOK(res1)) {
24782 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_header_get" "', argument " "1"" of type '" "struct layerObj *""'");
24783 : }
24784 0 : arg1 = (struct layerObj *)(argp1);
24785 0 : result = (char *) ((arg1)->header);
24786 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24787 0 : return resultobj;
24788 0 : fail:
24789 : return NULL;
24790 : }
24791 :
24792 :
24793 0 : SWIGINTERN PyObject *_wrap_layerObj_footer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24794 : PyObject *resultobj = 0;
24795 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24796 : char *arg2 = (char *) 0 ;
24797 0 : void *argp1 = 0 ;
24798 : int res1 = 0 ;
24799 : int res2 ;
24800 0 : char *buf2 = 0 ;
24801 0 : int alloc2 = 0 ;
24802 0 : PyObject * obj0 = 0 ;
24803 0 : PyObject * obj1 = 0 ;
24804 :
24805 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_footer_set",&obj0,&obj1)) SWIG_fail;
24806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24807 0 : if (!SWIG_IsOK(res1)) {
24808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_footer_set" "', argument " "1"" of type '" "struct layerObj *""'");
24809 : }
24810 0 : arg1 = (struct layerObj *)(argp1);
24811 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24812 0 : if (!SWIG_IsOK(res2)) {
24813 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_footer_set" "', argument " "2"" of type '" "char *""'");
24814 : }
24815 0 : arg2 = (char *)(buf2);
24816 : {
24817 0 : if (arg1->footer) free((char*)arg1->footer);
24818 0 : if (arg2) {
24819 0 : arg1->footer = (char *) malloc(strlen(arg2)+1);
24820 : strcpy((char*)arg1->footer,arg2);
24821 : } else {
24822 0 : arg1->footer = 0;
24823 : }
24824 : }
24825 : resultobj = SWIG_Py_Void();
24826 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24827 : return resultobj;
24828 0 : fail:
24829 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24830 : return NULL;
24831 : }
24832 :
24833 :
24834 0 : SWIGINTERN PyObject *_wrap_layerObj_footer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24835 : PyObject *resultobj = 0;
24836 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24837 0 : void *argp1 = 0 ;
24838 : int res1 = 0 ;
24839 0 : PyObject * obj0 = 0 ;
24840 : char *result = 0 ;
24841 :
24842 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_footer_get",&obj0)) SWIG_fail;
24843 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24844 0 : if (!SWIG_IsOK(res1)) {
24845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_footer_get" "', argument " "1"" of type '" "struct layerObj *""'");
24846 : }
24847 0 : arg1 = (struct layerObj *)(argp1);
24848 0 : result = (char *) ((arg1)->footer);
24849 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24850 0 : return resultobj;
24851 0 : fail:
24852 : return NULL;
24853 : }
24854 :
24855 :
24856 1 : SWIGINTERN PyObject *_wrap_layerObj_template_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24857 : PyObject *resultobj = 0;
24858 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24859 : char *arg2 = (char *) 0 ;
24860 1 : void *argp1 = 0 ;
24861 : int res1 = 0 ;
24862 : int res2 ;
24863 1 : char *buf2 = 0 ;
24864 1 : int alloc2 = 0 ;
24865 1 : PyObject * obj0 = 0 ;
24866 1 : PyObject * obj1 = 0 ;
24867 :
24868 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_template_set",&obj0,&obj1)) SWIG_fail;
24869 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24870 1 : if (!SWIG_IsOK(res1)) {
24871 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_template_set" "', argument " "1"" of type '" "struct layerObj *""'");
24872 : }
24873 1 : arg1 = (struct layerObj *)(argp1);
24874 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24875 1 : if (!SWIG_IsOK(res2)) {
24876 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_template_set" "', argument " "2"" of type '" "char *""'");
24877 : }
24878 1 : arg2 = (char *)(buf2);
24879 : {
24880 1 : if (arg1->template) free((char*)arg1->template);
24881 1 : if (arg2) {
24882 1 : arg1->template = (char *) malloc(strlen(arg2)+1);
24883 : strcpy((char*)arg1->template,arg2);
24884 : } else {
24885 0 : arg1->template = 0;
24886 : }
24887 : }
24888 : resultobj = SWIG_Py_Void();
24889 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24890 : return resultobj;
24891 0 : fail:
24892 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24893 : return NULL;
24894 : }
24895 :
24896 :
24897 0 : SWIGINTERN PyObject *_wrap_layerObj_template_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24898 : PyObject *resultobj = 0;
24899 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24900 0 : void *argp1 = 0 ;
24901 : int res1 = 0 ;
24902 0 : PyObject * obj0 = 0 ;
24903 : char *result = 0 ;
24904 :
24905 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_template_get",&obj0)) SWIG_fail;
24906 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24907 0 : if (!SWIG_IsOK(res1)) {
24908 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_template_get" "', argument " "1"" of type '" "struct layerObj *""'");
24909 : }
24910 0 : arg1 = (struct layerObj *)(argp1);
24911 0 : result = (char *) ((arg1)->template);
24912 0 : resultobj = SWIG_FromCharPtr((const char *)result);
24913 0 : return resultobj;
24914 0 : fail:
24915 : return NULL;
24916 : }
24917 :
24918 :
24919 1 : SWIGINTERN PyObject *_wrap_layerObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24920 : PyObject *resultobj = 0;
24921 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24922 : char *arg2 = (char *) 0 ;
24923 1 : void *argp1 = 0 ;
24924 : int res1 = 0 ;
24925 : int res2 ;
24926 1 : char *buf2 = 0 ;
24927 1 : int alloc2 = 0 ;
24928 1 : PyObject * obj0 = 0 ;
24929 1 : PyObject * obj1 = 0 ;
24930 :
24931 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_name_set",&obj0,&obj1)) SWIG_fail;
24932 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24933 1 : if (!SWIG_IsOK(res1)) {
24934 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_name_set" "', argument " "1"" of type '" "struct layerObj *""'");
24935 : }
24936 1 : arg1 = (struct layerObj *)(argp1);
24937 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24938 1 : if (!SWIG_IsOK(res2)) {
24939 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_name_set" "', argument " "2"" of type '" "char *""'");
24940 : }
24941 1 : arg2 = (char *)(buf2);
24942 : {
24943 1 : if (arg1->name) free((char*)arg1->name);
24944 1 : if (arg2) {
24945 1 : arg1->name = (char *) malloc(strlen(arg2)+1);
24946 : strcpy((char*)arg1->name,arg2);
24947 : } else {
24948 0 : arg1->name = 0;
24949 : }
24950 : }
24951 : resultobj = SWIG_Py_Void();
24952 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24953 : return resultobj;
24954 0 : fail:
24955 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24956 : return NULL;
24957 : }
24958 :
24959 :
24960 1 : SWIGINTERN PyObject *_wrap_layerObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24961 : PyObject *resultobj = 0;
24962 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24963 1 : void *argp1 = 0 ;
24964 : int res1 = 0 ;
24965 1 : PyObject * obj0 = 0 ;
24966 : char *result = 0 ;
24967 :
24968 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_name_get",&obj0)) SWIG_fail;
24969 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24970 1 : if (!SWIG_IsOK(res1)) {
24971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_name_get" "', argument " "1"" of type '" "struct layerObj *""'");
24972 : }
24973 1 : arg1 = (struct layerObj *)(argp1);
24974 1 : result = (char *) ((arg1)->name);
24975 1 : resultobj = SWIG_FromCharPtr((const char *)result);
24976 1 : return resultobj;
24977 0 : fail:
24978 : return NULL;
24979 : }
24980 :
24981 :
24982 0 : SWIGINTERN PyObject *_wrap_layerObj_group_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24983 : PyObject *resultobj = 0;
24984 : struct layerObj *arg1 = (struct layerObj *) 0 ;
24985 : char *arg2 = (char *) 0 ;
24986 0 : void *argp1 = 0 ;
24987 : int res1 = 0 ;
24988 : int res2 ;
24989 0 : char *buf2 = 0 ;
24990 0 : int alloc2 = 0 ;
24991 0 : PyObject * obj0 = 0 ;
24992 0 : PyObject * obj1 = 0 ;
24993 :
24994 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_group_set",&obj0,&obj1)) SWIG_fail;
24995 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
24996 0 : if (!SWIG_IsOK(res1)) {
24997 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_group_set" "', argument " "1"" of type '" "struct layerObj *""'");
24998 : }
24999 0 : arg1 = (struct layerObj *)(argp1);
25000 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25001 0 : if (!SWIG_IsOK(res2)) {
25002 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_group_set" "', argument " "2"" of type '" "char *""'");
25003 : }
25004 0 : arg2 = (char *)(buf2);
25005 : {
25006 0 : if (arg1->group) free((char*)arg1->group);
25007 0 : if (arg2) {
25008 0 : arg1->group = (char *) malloc(strlen(arg2)+1);
25009 : strcpy((char*)arg1->group,arg2);
25010 : } else {
25011 0 : arg1->group = 0;
25012 : }
25013 : }
25014 : resultobj = SWIG_Py_Void();
25015 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25016 : return resultobj;
25017 0 : fail:
25018 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25019 : return NULL;
25020 : }
25021 :
25022 :
25023 0 : SWIGINTERN PyObject *_wrap_layerObj_group_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25024 : PyObject *resultobj = 0;
25025 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25026 0 : void *argp1 = 0 ;
25027 : int res1 = 0 ;
25028 0 : PyObject * obj0 = 0 ;
25029 : char *result = 0 ;
25030 :
25031 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_group_get",&obj0)) SWIG_fail;
25032 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25033 0 : if (!SWIG_IsOK(res1)) {
25034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_group_get" "', argument " "1"" of type '" "struct layerObj *""'");
25035 : }
25036 0 : arg1 = (struct layerObj *)(argp1);
25037 0 : result = (char *) ((arg1)->group);
25038 0 : resultobj = SWIG_FromCharPtr((const char *)result);
25039 0 : return resultobj;
25040 0 : fail:
25041 : return NULL;
25042 : }
25043 :
25044 :
25045 1 : SWIGINTERN PyObject *_wrap_layerObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25046 : PyObject *resultobj = 0;
25047 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25048 : int arg2 ;
25049 1 : void *argp1 = 0 ;
25050 : int res1 = 0 ;
25051 : int val2 ;
25052 : int ecode2 = 0 ;
25053 1 : PyObject * obj0 = 0 ;
25054 1 : PyObject * obj1 = 0 ;
25055 :
25056 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_status_set",&obj0,&obj1)) SWIG_fail;
25057 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25058 1 : if (!SWIG_IsOK(res1)) {
25059 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_status_set" "', argument " "1"" of type '" "struct layerObj *""'");
25060 : }
25061 1 : arg1 = (struct layerObj *)(argp1);
25062 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25063 1 : if (!SWIG_IsOK(ecode2)) {
25064 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_status_set" "', argument " "2"" of type '" "int""'");
25065 : }
25066 : arg2 = (int)(val2);
25067 1 : if (arg1) (arg1)->status = arg2;
25068 : resultobj = SWIG_Py_Void();
25069 1 : return resultobj;
25070 0 : fail:
25071 : return NULL;
25072 : }
25073 :
25074 :
25075 0 : SWIGINTERN PyObject *_wrap_layerObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25076 : PyObject *resultobj = 0;
25077 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25078 0 : void *argp1 = 0 ;
25079 : int res1 = 0 ;
25080 0 : PyObject * obj0 = 0 ;
25081 : int result;
25082 :
25083 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_status_get",&obj0)) SWIG_fail;
25084 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25085 0 : if (!SWIG_IsOK(res1)) {
25086 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_status_get" "', argument " "1"" of type '" "struct layerObj *""'");
25087 : }
25088 0 : arg1 = (struct layerObj *)(argp1);
25089 0 : result = (int) ((arg1)->status);
25090 : resultobj = SWIG_From_int((int)(result));
25091 0 : return resultobj;
25092 0 : fail:
25093 : return NULL;
25094 : }
25095 :
25096 :
25097 0 : SWIGINTERN PyObject *_wrap_layerObj_rendermode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 : PyObject *resultobj = 0;
25099 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25100 : enum MS_RENDER_MODE arg2 ;
25101 0 : void *argp1 = 0 ;
25102 : int res1 = 0 ;
25103 : int val2 ;
25104 : int ecode2 = 0 ;
25105 0 : PyObject * obj0 = 0 ;
25106 0 : PyObject * obj1 = 0 ;
25107 :
25108 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_rendermode_set",&obj0,&obj1)) SWIG_fail;
25109 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25110 0 : if (!SWIG_IsOK(res1)) {
25111 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_rendermode_set" "', argument " "1"" of type '" "struct layerObj *""'");
25112 : }
25113 0 : arg1 = (struct layerObj *)(argp1);
25114 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25115 0 : if (!SWIG_IsOK(ecode2)) {
25116 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_rendermode_set" "', argument " "2"" of type '" "enum MS_RENDER_MODE""'");
25117 : }
25118 0 : arg2 = (enum MS_RENDER_MODE)(val2);
25119 0 : if (arg1) (arg1)->rendermode = arg2;
25120 : resultobj = SWIG_Py_Void();
25121 0 : return resultobj;
25122 0 : fail:
25123 : return NULL;
25124 : }
25125 :
25126 :
25127 0 : SWIGINTERN PyObject *_wrap_layerObj_rendermode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25128 : PyObject *resultobj = 0;
25129 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25130 0 : void *argp1 = 0 ;
25131 : int res1 = 0 ;
25132 0 : PyObject * obj0 = 0 ;
25133 : enum MS_RENDER_MODE result;
25134 :
25135 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_rendermode_get",&obj0)) SWIG_fail;
25136 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25137 0 : if (!SWIG_IsOK(res1)) {
25138 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_rendermode_get" "', argument " "1"" of type '" "struct layerObj *""'");
25139 : }
25140 0 : arg1 = (struct layerObj *)(argp1);
25141 0 : result = (enum MS_RENDER_MODE) ((arg1)->rendermode);
25142 0 : resultobj = SWIG_From_int((int)(result));
25143 0 : return resultobj;
25144 0 : fail:
25145 : return NULL;
25146 : }
25147 :
25148 :
25149 1 : SWIGINTERN PyObject *_wrap_layerObj_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25150 : PyObject *resultobj = 0;
25151 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25152 : char *arg2 = (char *) 0 ;
25153 1 : void *argp1 = 0 ;
25154 : int res1 = 0 ;
25155 : int res2 ;
25156 1 : char *buf2 = 0 ;
25157 1 : int alloc2 = 0 ;
25158 1 : PyObject * obj0 = 0 ;
25159 1 : PyObject * obj1 = 0 ;
25160 :
25161 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_data_set",&obj0,&obj1)) SWIG_fail;
25162 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25163 1 : if (!SWIG_IsOK(res1)) {
25164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_data_set" "', argument " "1"" of type '" "struct layerObj *""'");
25165 : }
25166 1 : arg1 = (struct layerObj *)(argp1);
25167 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
25168 1 : if (!SWIG_IsOK(res2)) {
25169 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_data_set" "', argument " "2"" of type '" "char *""'");
25170 : }
25171 1 : arg2 = (char *)(buf2);
25172 : {
25173 1 : if (arg1->data) free((char*)arg1->data);
25174 1 : if (arg2) {
25175 1 : arg1->data = (char *) malloc(strlen(arg2)+1);
25176 : strcpy((char*)arg1->data,arg2);
25177 : } else {
25178 0 : arg1->data = 0;
25179 : }
25180 : }
25181 : resultobj = SWIG_Py_Void();
25182 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25183 : return resultobj;
25184 0 : fail:
25185 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
25186 : return NULL;
25187 : }
25188 :
25189 :
25190 1 : SWIGINTERN PyObject *_wrap_layerObj_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25191 : PyObject *resultobj = 0;
25192 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25193 1 : void *argp1 = 0 ;
25194 : int res1 = 0 ;
25195 1 : PyObject * obj0 = 0 ;
25196 : char *result = 0 ;
25197 :
25198 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_data_get",&obj0)) SWIG_fail;
25199 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25200 1 : if (!SWIG_IsOK(res1)) {
25201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_data_get" "', argument " "1"" of type '" "struct layerObj *""'");
25202 : }
25203 1 : arg1 = (struct layerObj *)(argp1);
25204 1 : result = (char *) ((arg1)->data);
25205 1 : resultobj = SWIG_FromCharPtr((const char *)result);
25206 1 : return resultobj;
25207 0 : fail:
25208 : return NULL;
25209 : }
25210 :
25211 :
25212 1 : SWIGINTERN PyObject *_wrap_layerObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25213 : PyObject *resultobj = 0;
25214 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25215 : enum MS_LAYER_TYPE arg2 ;
25216 1 : void *argp1 = 0 ;
25217 : int res1 = 0 ;
25218 : int val2 ;
25219 : int ecode2 = 0 ;
25220 1 : PyObject * obj0 = 0 ;
25221 1 : PyObject * obj1 = 0 ;
25222 :
25223 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_type_set",&obj0,&obj1)) SWIG_fail;
25224 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25225 1 : if (!SWIG_IsOK(res1)) {
25226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_type_set" "', argument " "1"" of type '" "struct layerObj *""'");
25227 : }
25228 1 : arg1 = (struct layerObj *)(argp1);
25229 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25230 1 : if (!SWIG_IsOK(ecode2)) {
25231 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_type_set" "', argument " "2"" of type '" "enum MS_LAYER_TYPE""'");
25232 : }
25233 1 : arg2 = (enum MS_LAYER_TYPE)(val2);
25234 1 : if (arg1) (arg1)->type = arg2;
25235 : resultobj = SWIG_Py_Void();
25236 1 : return resultobj;
25237 0 : fail:
25238 : return NULL;
25239 : }
25240 :
25241 :
25242 1 : SWIGINTERN PyObject *_wrap_layerObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25243 : PyObject *resultobj = 0;
25244 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25245 1 : void *argp1 = 0 ;
25246 : int res1 = 0 ;
25247 1 : PyObject * obj0 = 0 ;
25248 : enum MS_LAYER_TYPE result;
25249 :
25250 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_type_get",&obj0)) SWIG_fail;
25251 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25252 1 : if (!SWIG_IsOK(res1)) {
25253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_type_get" "', argument " "1"" of type '" "struct layerObj *""'");
25254 : }
25255 1 : arg1 = (struct layerObj *)(argp1);
25256 1 : result = (enum MS_LAYER_TYPE) ((arg1)->type);
25257 1 : resultobj = SWIG_From_int((int)(result));
25258 1 : return resultobj;
25259 0 : fail:
25260 : return NULL;
25261 : }
25262 :
25263 :
25264 0 : SWIGINTERN PyObject *_wrap_layerObj_tolerance_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25265 : PyObject *resultobj = 0;
25266 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25267 : double arg2 ;
25268 0 : void *argp1 = 0 ;
25269 : int res1 = 0 ;
25270 : double val2 ;
25271 : int ecode2 = 0 ;
25272 0 : PyObject * obj0 = 0 ;
25273 0 : PyObject * obj1 = 0 ;
25274 :
25275 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tolerance_set",&obj0,&obj1)) SWIG_fail;
25276 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25277 0 : if (!SWIG_IsOK(res1)) {
25278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tolerance_set" "', argument " "1"" of type '" "struct layerObj *""'");
25279 : }
25280 0 : arg1 = (struct layerObj *)(argp1);
25281 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25282 0 : if (!SWIG_IsOK(ecode2)) {
25283 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_tolerance_set" "', argument " "2"" of type '" "double""'");
25284 : }
25285 0 : arg2 = (double)(val2);
25286 0 : if (arg1) (arg1)->tolerance = arg2;
25287 : resultobj = SWIG_Py_Void();
25288 0 : return resultobj;
25289 0 : fail:
25290 : return NULL;
25291 : }
25292 :
25293 :
25294 0 : SWIGINTERN PyObject *_wrap_layerObj_tolerance_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 : PyObject *resultobj = 0;
25296 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25297 0 : void *argp1 = 0 ;
25298 : int res1 = 0 ;
25299 0 : PyObject * obj0 = 0 ;
25300 : double result;
25301 :
25302 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tolerance_get",&obj0)) SWIG_fail;
25303 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25304 0 : if (!SWIG_IsOK(res1)) {
25305 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tolerance_get" "', argument " "1"" of type '" "struct layerObj *""'");
25306 : }
25307 0 : arg1 = (struct layerObj *)(argp1);
25308 0 : result = (double) ((arg1)->tolerance);
25309 0 : resultobj = SWIG_From_double((double)(result));
25310 0 : return resultobj;
25311 0 : fail:
25312 : return NULL;
25313 : }
25314 :
25315 :
25316 0 : SWIGINTERN PyObject *_wrap_layerObj_toleranceunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25317 : PyObject *resultobj = 0;
25318 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25319 : int arg2 ;
25320 0 : void *argp1 = 0 ;
25321 : int res1 = 0 ;
25322 : int val2 ;
25323 : int ecode2 = 0 ;
25324 0 : PyObject * obj0 = 0 ;
25325 0 : PyObject * obj1 = 0 ;
25326 :
25327 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_toleranceunits_set",&obj0,&obj1)) SWIG_fail;
25328 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25329 0 : if (!SWIG_IsOK(res1)) {
25330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_toleranceunits_set" "', argument " "1"" of type '" "struct layerObj *""'");
25331 : }
25332 0 : arg1 = (struct layerObj *)(argp1);
25333 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25334 0 : if (!SWIG_IsOK(ecode2)) {
25335 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_toleranceunits_set" "', argument " "2"" of type '" "int""'");
25336 : }
25337 : arg2 = (int)(val2);
25338 0 : if (arg1) (arg1)->toleranceunits = arg2;
25339 : resultobj = SWIG_Py_Void();
25340 0 : return resultobj;
25341 0 : fail:
25342 : return NULL;
25343 : }
25344 :
25345 :
25346 0 : SWIGINTERN PyObject *_wrap_layerObj_toleranceunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25347 : PyObject *resultobj = 0;
25348 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25349 0 : void *argp1 = 0 ;
25350 : int res1 = 0 ;
25351 0 : PyObject * obj0 = 0 ;
25352 : int result;
25353 :
25354 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_toleranceunits_get",&obj0)) SWIG_fail;
25355 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25356 0 : if (!SWIG_IsOK(res1)) {
25357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_toleranceunits_get" "', argument " "1"" of type '" "struct layerObj *""'");
25358 : }
25359 0 : arg1 = (struct layerObj *)(argp1);
25360 0 : result = (int) ((arg1)->toleranceunits);
25361 : resultobj = SWIG_From_int((int)(result));
25362 0 : return resultobj;
25363 0 : fail:
25364 : return NULL;
25365 : }
25366 :
25367 :
25368 0 : SWIGINTERN PyObject *_wrap_layerObj_symbolscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25369 : PyObject *resultobj = 0;
25370 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25371 : double arg2 ;
25372 0 : void *argp1 = 0 ;
25373 : int res1 = 0 ;
25374 : double val2 ;
25375 : int ecode2 = 0 ;
25376 0 : PyObject * obj0 = 0 ;
25377 0 : PyObject * obj1 = 0 ;
25378 :
25379 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_symbolscaledenom_set",&obj0,&obj1)) SWIG_fail;
25380 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25381 0 : if (!SWIG_IsOK(res1)) {
25382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_symbolscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'");
25383 : }
25384 0 : arg1 = (struct layerObj *)(argp1);
25385 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25386 0 : if (!SWIG_IsOK(ecode2)) {
25387 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_symbolscaledenom_set" "', argument " "2"" of type '" "double""'");
25388 : }
25389 0 : arg2 = (double)(val2);
25390 0 : if (arg1) (arg1)->symbolscaledenom = arg2;
25391 : resultobj = SWIG_Py_Void();
25392 0 : return resultobj;
25393 0 : fail:
25394 : return NULL;
25395 : }
25396 :
25397 :
25398 0 : SWIGINTERN PyObject *_wrap_layerObj_symbolscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25399 : PyObject *resultobj = 0;
25400 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25401 0 : void *argp1 = 0 ;
25402 : int res1 = 0 ;
25403 0 : PyObject * obj0 = 0 ;
25404 : double result;
25405 :
25406 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_symbolscaledenom_get",&obj0)) SWIG_fail;
25407 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25408 0 : if (!SWIG_IsOK(res1)) {
25409 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_symbolscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'");
25410 : }
25411 0 : arg1 = (struct layerObj *)(argp1);
25412 0 : result = (double) ((arg1)->symbolscaledenom);
25413 0 : resultobj = SWIG_From_double((double)(result));
25414 0 : return resultobj;
25415 0 : fail:
25416 : return NULL;
25417 : }
25418 :
25419 :
25420 1 : SWIGINTERN PyObject *_wrap_layerObj_minscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25421 : PyObject *resultobj = 0;
25422 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25423 : double arg2 ;
25424 1 : void *argp1 = 0 ;
25425 : int res1 = 0 ;
25426 : double val2 ;
25427 : int ecode2 = 0 ;
25428 1 : PyObject * obj0 = 0 ;
25429 1 : PyObject * obj1 = 0 ;
25430 :
25431 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_minscaledenom_set",&obj0,&obj1)) SWIG_fail;
25432 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25433 1 : if (!SWIG_IsOK(res1)) {
25434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'");
25435 : }
25436 1 : arg1 = (struct layerObj *)(argp1);
25437 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25438 1 : if (!SWIG_IsOK(ecode2)) {
25439 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_minscaledenom_set" "', argument " "2"" of type '" "double""'");
25440 : }
25441 1 : arg2 = (double)(val2);
25442 1 : if (arg1) (arg1)->minscaledenom = arg2;
25443 : resultobj = SWIG_Py_Void();
25444 1 : return resultobj;
25445 0 : fail:
25446 : return NULL;
25447 : }
25448 :
25449 :
25450 0 : SWIGINTERN PyObject *_wrap_layerObj_minscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25451 : PyObject *resultobj = 0;
25452 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25453 0 : void *argp1 = 0 ;
25454 : int res1 = 0 ;
25455 0 : PyObject * obj0 = 0 ;
25456 : double result;
25457 :
25458 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_minscaledenom_get",&obj0)) SWIG_fail;
25459 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25460 0 : if (!SWIG_IsOK(res1)) {
25461 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'");
25462 : }
25463 0 : arg1 = (struct layerObj *)(argp1);
25464 0 : result = (double) ((arg1)->minscaledenom);
25465 0 : resultobj = SWIG_From_double((double)(result));
25466 0 : return resultobj;
25467 0 : fail:
25468 : return NULL;
25469 : }
25470 :
25471 :
25472 1 : SWIGINTERN PyObject *_wrap_layerObj_maxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25473 : PyObject *resultobj = 0;
25474 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25475 : double arg2 ;
25476 1 : void *argp1 = 0 ;
25477 : int res1 = 0 ;
25478 : double val2 ;
25479 : int ecode2 = 0 ;
25480 1 : PyObject * obj0 = 0 ;
25481 1 : PyObject * obj1 = 0 ;
25482 :
25483 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxscaledenom_set",&obj0,&obj1)) SWIG_fail;
25484 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25485 1 : if (!SWIG_IsOK(res1)) {
25486 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'");
25487 : }
25488 1 : arg1 = (struct layerObj *)(argp1);
25489 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25490 1 : if (!SWIG_IsOK(ecode2)) {
25491 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxscaledenom_set" "', argument " "2"" of type '" "double""'");
25492 : }
25493 1 : arg2 = (double)(val2);
25494 1 : if (arg1) (arg1)->maxscaledenom = arg2;
25495 : resultobj = SWIG_Py_Void();
25496 1 : return resultobj;
25497 0 : fail:
25498 : return NULL;
25499 : }
25500 :
25501 :
25502 0 : SWIGINTERN PyObject *_wrap_layerObj_maxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25503 : PyObject *resultobj = 0;
25504 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25505 0 : void *argp1 = 0 ;
25506 : int res1 = 0 ;
25507 0 : PyObject * obj0 = 0 ;
25508 : double result;
25509 :
25510 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxscaledenom_get",&obj0)) SWIG_fail;
25511 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25512 0 : if (!SWIG_IsOK(res1)) {
25513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'");
25514 : }
25515 0 : arg1 = (struct layerObj *)(argp1);
25516 0 : result = (double) ((arg1)->maxscaledenom);
25517 0 : resultobj = SWIG_From_double((double)(result));
25518 0 : return resultobj;
25519 0 : fail:
25520 : return NULL;
25521 : }
25522 :
25523 :
25524 0 : SWIGINTERN PyObject *_wrap_layerObj_minfeaturesize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 : PyObject *resultobj = 0;
25526 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25527 : int arg2 ;
25528 0 : void *argp1 = 0 ;
25529 : int res1 = 0 ;
25530 : int val2 ;
25531 : int ecode2 = 0 ;
25532 0 : PyObject * obj0 = 0 ;
25533 0 : PyObject * obj1 = 0 ;
25534 :
25535 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_minfeaturesize_set",&obj0,&obj1)) SWIG_fail;
25536 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25537 0 : if (!SWIG_IsOK(res1)) {
25538 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minfeaturesize_set" "', argument " "1"" of type '" "struct layerObj *""'");
25539 : }
25540 0 : arg1 = (struct layerObj *)(argp1);
25541 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25542 0 : if (!SWIG_IsOK(ecode2)) {
25543 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_minfeaturesize_set" "', argument " "2"" of type '" "int""'");
25544 : }
25545 : arg2 = (int)(val2);
25546 0 : if (arg1) (arg1)->minfeaturesize = arg2;
25547 : resultobj = SWIG_Py_Void();
25548 0 : return resultobj;
25549 0 : fail:
25550 : return NULL;
25551 : }
25552 :
25553 :
25554 0 : SWIGINTERN PyObject *_wrap_layerObj_minfeaturesize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25555 : PyObject *resultobj = 0;
25556 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25557 0 : void *argp1 = 0 ;
25558 : int res1 = 0 ;
25559 0 : PyObject * obj0 = 0 ;
25560 : int result;
25561 :
25562 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_minfeaturesize_get",&obj0)) SWIG_fail;
25563 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25564 0 : if (!SWIG_IsOK(res1)) {
25565 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_minfeaturesize_get" "', argument " "1"" of type '" "struct layerObj *""'");
25566 : }
25567 0 : arg1 = (struct layerObj *)(argp1);
25568 0 : result = (int) ((arg1)->minfeaturesize);
25569 : resultobj = SWIG_From_int((int)(result));
25570 0 : return resultobj;
25571 0 : fail:
25572 : return NULL;
25573 : }
25574 :
25575 :
25576 0 : SWIGINTERN PyObject *_wrap_layerObj_labelminscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25577 : PyObject *resultobj = 0;
25578 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25579 : double arg2 ;
25580 0 : void *argp1 = 0 ;
25581 : int res1 = 0 ;
25582 : double val2 ;
25583 : int ecode2 = 0 ;
25584 0 : PyObject * obj0 = 0 ;
25585 0 : PyObject * obj1 = 0 ;
25586 :
25587 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelminscaledenom_set",&obj0,&obj1)) SWIG_fail;
25588 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25589 0 : if (!SWIG_IsOK(res1)) {
25590 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelminscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'");
25591 : }
25592 0 : arg1 = (struct layerObj *)(argp1);
25593 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25594 0 : if (!SWIG_IsOK(ecode2)) {
25595 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelminscaledenom_set" "', argument " "2"" of type '" "double""'");
25596 : }
25597 0 : arg2 = (double)(val2);
25598 0 : if (arg1) (arg1)->labelminscaledenom = arg2;
25599 : resultobj = SWIG_Py_Void();
25600 0 : return resultobj;
25601 0 : fail:
25602 : return NULL;
25603 : }
25604 :
25605 :
25606 0 : SWIGINTERN PyObject *_wrap_layerObj_labelminscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25607 : PyObject *resultobj = 0;
25608 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25609 0 : void *argp1 = 0 ;
25610 : int res1 = 0 ;
25611 0 : PyObject * obj0 = 0 ;
25612 : double result;
25613 :
25614 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelminscaledenom_get",&obj0)) SWIG_fail;
25615 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25616 0 : if (!SWIG_IsOK(res1)) {
25617 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelminscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'");
25618 : }
25619 0 : arg1 = (struct layerObj *)(argp1);
25620 0 : result = (double) ((arg1)->labelminscaledenom);
25621 0 : resultobj = SWIG_From_double((double)(result));
25622 0 : return resultobj;
25623 0 : fail:
25624 : return NULL;
25625 : }
25626 :
25627 :
25628 0 : SWIGINTERN PyObject *_wrap_layerObj_labelmaxscaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25629 : PyObject *resultobj = 0;
25630 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25631 : double arg2 ;
25632 0 : void *argp1 = 0 ;
25633 : int res1 = 0 ;
25634 : double val2 ;
25635 : int ecode2 = 0 ;
25636 0 : PyObject * obj0 = 0 ;
25637 0 : PyObject * obj1 = 0 ;
25638 :
25639 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelmaxscaledenom_set",&obj0,&obj1)) SWIG_fail;
25640 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25641 0 : if (!SWIG_IsOK(res1)) {
25642 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelmaxscaledenom_set" "', argument " "1"" of type '" "struct layerObj *""'");
25643 : }
25644 0 : arg1 = (struct layerObj *)(argp1);
25645 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25646 0 : if (!SWIG_IsOK(ecode2)) {
25647 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelmaxscaledenom_set" "', argument " "2"" of type '" "double""'");
25648 : }
25649 0 : arg2 = (double)(val2);
25650 0 : if (arg1) (arg1)->labelmaxscaledenom = arg2;
25651 : resultobj = SWIG_Py_Void();
25652 0 : return resultobj;
25653 0 : fail:
25654 : return NULL;
25655 : }
25656 :
25657 :
25658 0 : SWIGINTERN PyObject *_wrap_layerObj_labelmaxscaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25659 : PyObject *resultobj = 0;
25660 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25661 0 : void *argp1 = 0 ;
25662 : int res1 = 0 ;
25663 0 : PyObject * obj0 = 0 ;
25664 : double result;
25665 :
25666 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelmaxscaledenom_get",&obj0)) SWIG_fail;
25667 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25668 0 : if (!SWIG_IsOK(res1)) {
25669 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelmaxscaledenom_get" "', argument " "1"" of type '" "struct layerObj *""'");
25670 : }
25671 0 : arg1 = (struct layerObj *)(argp1);
25672 0 : result = (double) ((arg1)->labelmaxscaledenom);
25673 0 : resultobj = SWIG_From_double((double)(result));
25674 0 : return resultobj;
25675 0 : fail:
25676 : return NULL;
25677 : }
25678 :
25679 :
25680 0 : SWIGINTERN PyObject *_wrap_layerObj_mingeowidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25681 : PyObject *resultobj = 0;
25682 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25683 : double arg2 ;
25684 0 : void *argp1 = 0 ;
25685 : int res1 = 0 ;
25686 : double val2 ;
25687 : int ecode2 = 0 ;
25688 0 : PyObject * obj0 = 0 ;
25689 0 : PyObject * obj1 = 0 ;
25690 :
25691 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_mingeowidth_set",&obj0,&obj1)) SWIG_fail;
25692 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25693 0 : if (!SWIG_IsOK(res1)) {
25694 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mingeowidth_set" "', argument " "1"" of type '" "struct layerObj *""'");
25695 : }
25696 0 : arg1 = (struct layerObj *)(argp1);
25697 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25698 0 : if (!SWIG_IsOK(ecode2)) {
25699 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_mingeowidth_set" "', argument " "2"" of type '" "double""'");
25700 : }
25701 0 : arg2 = (double)(val2);
25702 0 : if (arg1) (arg1)->mingeowidth = arg2;
25703 : resultobj = SWIG_Py_Void();
25704 0 : return resultobj;
25705 0 : fail:
25706 : return NULL;
25707 : }
25708 :
25709 :
25710 0 : SWIGINTERN PyObject *_wrap_layerObj_mingeowidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25711 : PyObject *resultobj = 0;
25712 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25713 0 : void *argp1 = 0 ;
25714 : int res1 = 0 ;
25715 0 : PyObject * obj0 = 0 ;
25716 : double result;
25717 :
25718 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_mingeowidth_get",&obj0)) SWIG_fail;
25719 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25720 0 : if (!SWIG_IsOK(res1)) {
25721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mingeowidth_get" "', argument " "1"" of type '" "struct layerObj *""'");
25722 : }
25723 0 : arg1 = (struct layerObj *)(argp1);
25724 0 : result = (double) ((arg1)->mingeowidth);
25725 0 : resultobj = SWIG_From_double((double)(result));
25726 0 : return resultobj;
25727 0 : fail:
25728 : return NULL;
25729 : }
25730 :
25731 :
25732 0 : SWIGINTERN PyObject *_wrap_layerObj_maxgeowidth_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25733 : PyObject *resultobj = 0;
25734 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25735 : double arg2 ;
25736 0 : void *argp1 = 0 ;
25737 : int res1 = 0 ;
25738 : double val2 ;
25739 : int ecode2 = 0 ;
25740 0 : PyObject * obj0 = 0 ;
25741 0 : PyObject * obj1 = 0 ;
25742 :
25743 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxgeowidth_set",&obj0,&obj1)) SWIG_fail;
25744 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25745 0 : if (!SWIG_IsOK(res1)) {
25746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxgeowidth_set" "', argument " "1"" of type '" "struct layerObj *""'");
25747 : }
25748 0 : arg1 = (struct layerObj *)(argp1);
25749 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
25750 0 : if (!SWIG_IsOK(ecode2)) {
25751 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxgeowidth_set" "', argument " "2"" of type '" "double""'");
25752 : }
25753 0 : arg2 = (double)(val2);
25754 0 : if (arg1) (arg1)->maxgeowidth = arg2;
25755 : resultobj = SWIG_Py_Void();
25756 0 : return resultobj;
25757 0 : fail:
25758 : return NULL;
25759 : }
25760 :
25761 :
25762 0 : SWIGINTERN PyObject *_wrap_layerObj_maxgeowidth_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25763 : PyObject *resultobj = 0;
25764 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25765 0 : void *argp1 = 0 ;
25766 : int res1 = 0 ;
25767 0 : PyObject * obj0 = 0 ;
25768 : double result;
25769 :
25770 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxgeowidth_get",&obj0)) SWIG_fail;
25771 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25772 0 : if (!SWIG_IsOK(res1)) {
25773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxgeowidth_get" "', argument " "1"" of type '" "struct layerObj *""'");
25774 : }
25775 0 : arg1 = (struct layerObj *)(argp1);
25776 0 : result = (double) ((arg1)->maxgeowidth);
25777 0 : resultobj = SWIG_From_double((double)(result));
25778 0 : return resultobj;
25779 0 : fail:
25780 : return NULL;
25781 : }
25782 :
25783 :
25784 0 : SWIGINTERN PyObject *_wrap_layerObj_sizeunits_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25785 : PyObject *resultobj = 0;
25786 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25787 : int arg2 ;
25788 0 : void *argp1 = 0 ;
25789 : int res1 = 0 ;
25790 : int val2 ;
25791 : int ecode2 = 0 ;
25792 0 : PyObject * obj0 = 0 ;
25793 0 : PyObject * obj1 = 0 ;
25794 :
25795 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_sizeunits_set",&obj0,&obj1)) SWIG_fail;
25796 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25797 0 : if (!SWIG_IsOK(res1)) {
25798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_sizeunits_set" "', argument " "1"" of type '" "struct layerObj *""'");
25799 : }
25800 0 : arg1 = (struct layerObj *)(argp1);
25801 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25802 0 : if (!SWIG_IsOK(ecode2)) {
25803 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_sizeunits_set" "', argument " "2"" of type '" "int""'");
25804 : }
25805 : arg2 = (int)(val2);
25806 0 : if (arg1) (arg1)->sizeunits = arg2;
25807 : resultobj = SWIG_Py_Void();
25808 0 : return resultobj;
25809 0 : fail:
25810 : return NULL;
25811 : }
25812 :
25813 :
25814 0 : SWIGINTERN PyObject *_wrap_layerObj_sizeunits_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25815 : PyObject *resultobj = 0;
25816 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25817 0 : void *argp1 = 0 ;
25818 : int res1 = 0 ;
25819 0 : PyObject * obj0 = 0 ;
25820 : int result;
25821 :
25822 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_sizeunits_get",&obj0)) SWIG_fail;
25823 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25824 0 : if (!SWIG_IsOK(res1)) {
25825 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_sizeunits_get" "', argument " "1"" of type '" "struct layerObj *""'");
25826 : }
25827 0 : arg1 = (struct layerObj *)(argp1);
25828 0 : result = (int) ((arg1)->sizeunits);
25829 : resultobj = SWIG_From_int((int)(result));
25830 0 : return resultobj;
25831 0 : fail:
25832 : return NULL;
25833 : }
25834 :
25835 :
25836 0 : SWIGINTERN PyObject *_wrap_layerObj_maxfeatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25837 : PyObject *resultobj = 0;
25838 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25839 : int arg2 ;
25840 0 : void *argp1 = 0 ;
25841 : int res1 = 0 ;
25842 : int val2 ;
25843 : int ecode2 = 0 ;
25844 0 : PyObject * obj0 = 0 ;
25845 0 : PyObject * obj1 = 0 ;
25846 :
25847 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_maxfeatures_set",&obj0,&obj1)) SWIG_fail;
25848 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25849 0 : if (!SWIG_IsOK(res1)) {
25850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxfeatures_set" "', argument " "1"" of type '" "struct layerObj *""'");
25851 : }
25852 0 : arg1 = (struct layerObj *)(argp1);
25853 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25854 0 : if (!SWIG_IsOK(ecode2)) {
25855 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_maxfeatures_set" "', argument " "2"" of type '" "int""'");
25856 : }
25857 : arg2 = (int)(val2);
25858 0 : if (arg1) (arg1)->maxfeatures = arg2;
25859 : resultobj = SWIG_Py_Void();
25860 0 : return resultobj;
25861 0 : fail:
25862 : return NULL;
25863 : }
25864 :
25865 :
25866 0 : SWIGINTERN PyObject *_wrap_layerObj_maxfeatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25867 : PyObject *resultobj = 0;
25868 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25869 0 : void *argp1 = 0 ;
25870 : int res1 = 0 ;
25871 0 : PyObject * obj0 = 0 ;
25872 : int result;
25873 :
25874 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_maxfeatures_get",&obj0)) SWIG_fail;
25875 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25876 0 : if (!SWIG_IsOK(res1)) {
25877 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_maxfeatures_get" "', argument " "1"" of type '" "struct layerObj *""'");
25878 : }
25879 0 : arg1 = (struct layerObj *)(argp1);
25880 0 : result = (int) ((arg1)->maxfeatures);
25881 : resultobj = SWIG_From_int((int)(result));
25882 0 : return resultobj;
25883 0 : fail:
25884 : return NULL;
25885 : }
25886 :
25887 :
25888 0 : SWIGINTERN PyObject *_wrap_layerObj_startindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25889 : PyObject *resultobj = 0;
25890 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25891 : int arg2 ;
25892 0 : void *argp1 = 0 ;
25893 : int res1 = 0 ;
25894 : int val2 ;
25895 : int ecode2 = 0 ;
25896 0 : PyObject * obj0 = 0 ;
25897 0 : PyObject * obj1 = 0 ;
25898 :
25899 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_startindex_set",&obj0,&obj1)) SWIG_fail;
25900 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25901 0 : if (!SWIG_IsOK(res1)) {
25902 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_startindex_set" "', argument " "1"" of type '" "struct layerObj *""'");
25903 : }
25904 0 : arg1 = (struct layerObj *)(argp1);
25905 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25906 0 : if (!SWIG_IsOK(ecode2)) {
25907 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_startindex_set" "', argument " "2"" of type '" "int""'");
25908 : }
25909 : arg2 = (int)(val2);
25910 0 : if (arg1) (arg1)->startindex = arg2;
25911 : resultobj = SWIG_Py_Void();
25912 0 : return resultobj;
25913 0 : fail:
25914 : return NULL;
25915 : }
25916 :
25917 :
25918 0 : SWIGINTERN PyObject *_wrap_layerObj_startindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25919 : PyObject *resultobj = 0;
25920 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25921 0 : void *argp1 = 0 ;
25922 : int res1 = 0 ;
25923 0 : PyObject * obj0 = 0 ;
25924 : int result;
25925 :
25926 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_startindex_get",&obj0)) SWIG_fail;
25927 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25928 0 : if (!SWIG_IsOK(res1)) {
25929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_startindex_get" "', argument " "1"" of type '" "struct layerObj *""'");
25930 : }
25931 0 : arg1 = (struct layerObj *)(argp1);
25932 0 : result = (int) ((arg1)->startindex);
25933 : resultobj = SWIG_From_int((int)(result));
25934 0 : return resultobj;
25935 0 : fail:
25936 : return NULL;
25937 : }
25938 :
25939 :
25940 0 : SWIGINTERN PyObject *_wrap_layerObj_offsite_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25941 : PyObject *resultobj = 0;
25942 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25943 : colorObj *arg2 = (colorObj *) 0 ;
25944 0 : void *argp1 = 0 ;
25945 : int res1 = 0 ;
25946 0 : void *argp2 = 0 ;
25947 : int res2 = 0 ;
25948 0 : PyObject * obj0 = 0 ;
25949 0 : PyObject * obj1 = 0 ;
25950 :
25951 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_offsite_set",&obj0,&obj1)) SWIG_fail;
25952 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25953 0 : if (!SWIG_IsOK(res1)) {
25954 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_offsite_set" "', argument " "1"" of type '" "struct layerObj *""'");
25955 : }
25956 0 : arg1 = (struct layerObj *)(argp1);
25957 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
25958 0 : if (!SWIG_IsOK(res2)) {
25959 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_offsite_set" "', argument " "2"" of type '" "colorObj *""'");
25960 : }
25961 0 : arg2 = (colorObj *)(argp2);
25962 0 : if (arg1) (arg1)->offsite = *arg2;
25963 : resultobj = SWIG_Py_Void();
25964 0 : return resultobj;
25965 0 : fail:
25966 : return NULL;
25967 : }
25968 :
25969 :
25970 0 : SWIGINTERN PyObject *_wrap_layerObj_offsite_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25971 : PyObject *resultobj = 0;
25972 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25973 0 : void *argp1 = 0 ;
25974 : int res1 = 0 ;
25975 0 : PyObject * obj0 = 0 ;
25976 : colorObj *result = 0 ;
25977 :
25978 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_offsite_get",&obj0)) SWIG_fail;
25979 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
25980 0 : if (!SWIG_IsOK(res1)) {
25981 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_offsite_get" "', argument " "1"" of type '" "struct layerObj *""'");
25982 : }
25983 0 : arg1 = (struct layerObj *)(argp1);
25984 0 : result = (colorObj *)& ((arg1)->offsite);
25985 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
25986 0 : return resultobj;
25987 0 : fail:
25988 : return NULL;
25989 : }
25990 :
25991 :
25992 0 : SWIGINTERN PyObject *_wrap_layerObj_transform_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25993 : PyObject *resultobj = 0;
25994 : struct layerObj *arg1 = (struct layerObj *) 0 ;
25995 : int arg2 ;
25996 0 : void *argp1 = 0 ;
25997 : int res1 = 0 ;
25998 : int val2 ;
25999 : int ecode2 = 0 ;
26000 0 : PyObject * obj0 = 0 ;
26001 0 : PyObject * obj1 = 0 ;
26002 :
26003 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_transform_set",&obj0,&obj1)) SWIG_fail;
26004 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26005 0 : if (!SWIG_IsOK(res1)) {
26006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_transform_set" "', argument " "1"" of type '" "struct layerObj *""'");
26007 : }
26008 0 : arg1 = (struct layerObj *)(argp1);
26009 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26010 0 : if (!SWIG_IsOK(ecode2)) {
26011 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_transform_set" "', argument " "2"" of type '" "int""'");
26012 : }
26013 : arg2 = (int)(val2);
26014 0 : if (arg1) (arg1)->transform = arg2;
26015 : resultobj = SWIG_Py_Void();
26016 0 : return resultobj;
26017 0 : fail:
26018 : return NULL;
26019 : }
26020 :
26021 :
26022 0 : SWIGINTERN PyObject *_wrap_layerObj_transform_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26023 : PyObject *resultobj = 0;
26024 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26025 0 : void *argp1 = 0 ;
26026 : int res1 = 0 ;
26027 0 : PyObject * obj0 = 0 ;
26028 : int result;
26029 :
26030 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_transform_get",&obj0)) SWIG_fail;
26031 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26032 0 : if (!SWIG_IsOK(res1)) {
26033 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_transform_get" "', argument " "1"" of type '" "struct layerObj *""'");
26034 : }
26035 0 : arg1 = (struct layerObj *)(argp1);
26036 0 : result = (int) ((arg1)->transform);
26037 : resultobj = SWIG_From_int((int)(result));
26038 0 : return resultobj;
26039 0 : fail:
26040 : return NULL;
26041 : }
26042 :
26043 :
26044 0 : SWIGINTERN PyObject *_wrap_layerObj_labelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26045 : PyObject *resultobj = 0;
26046 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26047 : int arg2 ;
26048 0 : void *argp1 = 0 ;
26049 : int res1 = 0 ;
26050 : int val2 ;
26051 : int ecode2 = 0 ;
26052 0 : PyObject * obj0 = 0 ;
26053 0 : PyObject * obj1 = 0 ;
26054 :
26055 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelcache_set",&obj0,&obj1)) SWIG_fail;
26056 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26057 0 : if (!SWIG_IsOK(res1)) {
26058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelcache_set" "', argument " "1"" of type '" "struct layerObj *""'");
26059 : }
26060 0 : arg1 = (struct layerObj *)(argp1);
26061 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26062 0 : if (!SWIG_IsOK(ecode2)) {
26063 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_labelcache_set" "', argument " "2"" of type '" "int""'");
26064 : }
26065 : arg2 = (int)(val2);
26066 0 : if (arg1) (arg1)->labelcache = arg2;
26067 : resultobj = SWIG_Py_Void();
26068 0 : return resultobj;
26069 0 : fail:
26070 : return NULL;
26071 : }
26072 :
26073 :
26074 0 : SWIGINTERN PyObject *_wrap_layerObj_labelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26075 : PyObject *resultobj = 0;
26076 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26077 0 : void *argp1 = 0 ;
26078 : int res1 = 0 ;
26079 0 : PyObject * obj0 = 0 ;
26080 : int result;
26081 :
26082 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelcache_get",&obj0)) SWIG_fail;
26083 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26084 0 : if (!SWIG_IsOK(res1)) {
26085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelcache_get" "', argument " "1"" of type '" "struct layerObj *""'");
26086 : }
26087 0 : arg1 = (struct layerObj *)(argp1);
26088 0 : result = (int) ((arg1)->labelcache);
26089 : resultobj = SWIG_From_int((int)(result));
26090 0 : return resultobj;
26091 0 : fail:
26092 : return NULL;
26093 : }
26094 :
26095 :
26096 0 : SWIGINTERN PyObject *_wrap_layerObj_postlabelcache_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26097 : PyObject *resultobj = 0;
26098 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26099 : int arg2 ;
26100 0 : void *argp1 = 0 ;
26101 : int res1 = 0 ;
26102 : int val2 ;
26103 : int ecode2 = 0 ;
26104 0 : PyObject * obj0 = 0 ;
26105 0 : PyObject * obj1 = 0 ;
26106 :
26107 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_postlabelcache_set",&obj0,&obj1)) SWIG_fail;
26108 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26109 0 : if (!SWIG_IsOK(res1)) {
26110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_postlabelcache_set" "', argument " "1"" of type '" "struct layerObj *""'");
26111 : }
26112 0 : arg1 = (struct layerObj *)(argp1);
26113 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26114 0 : if (!SWIG_IsOK(ecode2)) {
26115 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_postlabelcache_set" "', argument " "2"" of type '" "int""'");
26116 : }
26117 : arg2 = (int)(val2);
26118 0 : if (arg1) (arg1)->postlabelcache = arg2;
26119 : resultobj = SWIG_Py_Void();
26120 0 : return resultobj;
26121 0 : fail:
26122 : return NULL;
26123 : }
26124 :
26125 :
26126 0 : SWIGINTERN PyObject *_wrap_layerObj_postlabelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26127 : PyObject *resultobj = 0;
26128 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26129 0 : void *argp1 = 0 ;
26130 : int res1 = 0 ;
26131 0 : PyObject * obj0 = 0 ;
26132 : int result;
26133 :
26134 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_postlabelcache_get",&obj0)) SWIG_fail;
26135 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26136 0 : if (!SWIG_IsOK(res1)) {
26137 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_postlabelcache_get" "', argument " "1"" of type '" "struct layerObj *""'");
26138 : }
26139 0 : arg1 = (struct layerObj *)(argp1);
26140 0 : result = (int) ((arg1)->postlabelcache);
26141 : resultobj = SWIG_From_int((int)(result));
26142 0 : return resultobj;
26143 0 : fail:
26144 : return NULL;
26145 : }
26146 :
26147 :
26148 0 : SWIGINTERN PyObject *_wrap_layerObj_labelitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26149 : PyObject *resultobj = 0;
26150 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26151 : char *arg2 = (char *) 0 ;
26152 0 : void *argp1 = 0 ;
26153 : int res1 = 0 ;
26154 : int res2 ;
26155 0 : char *buf2 = 0 ;
26156 0 : int alloc2 = 0 ;
26157 0 : PyObject * obj0 = 0 ;
26158 0 : PyObject * obj1 = 0 ;
26159 :
26160 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelitem_set",&obj0,&obj1)) SWIG_fail;
26161 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26162 0 : if (!SWIG_IsOK(res1)) {
26163 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
26164 : }
26165 0 : arg1 = (struct layerObj *)(argp1);
26166 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26167 0 : if (!SWIG_IsOK(res2)) {
26168 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_labelitem_set" "', argument " "2"" of type '" "char *""'");
26169 : }
26170 0 : arg2 = (char *)(buf2);
26171 : {
26172 0 : if (arg1->labelitem) free((char*)arg1->labelitem);
26173 0 : if (arg2) {
26174 0 : arg1->labelitem = (char *) malloc(strlen(arg2)+1);
26175 : strcpy((char*)arg1->labelitem,arg2);
26176 : } else {
26177 0 : arg1->labelitem = 0;
26178 : }
26179 : }
26180 : resultobj = SWIG_Py_Void();
26181 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26182 : return resultobj;
26183 0 : fail:
26184 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26185 : return NULL;
26186 : }
26187 :
26188 :
26189 0 : SWIGINTERN PyObject *_wrap_layerObj_labelitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26190 : PyObject *resultobj = 0;
26191 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26192 0 : void *argp1 = 0 ;
26193 : int res1 = 0 ;
26194 0 : PyObject * obj0 = 0 ;
26195 : char *result = 0 ;
26196 :
26197 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelitem_get",&obj0)) SWIG_fail;
26198 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26199 0 : if (!SWIG_IsOK(res1)) {
26200 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
26201 : }
26202 0 : arg1 = (struct layerObj *)(argp1);
26203 0 : result = (char *) ((arg1)->labelitem);
26204 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26205 0 : return resultobj;
26206 0 : fail:
26207 : return NULL;
26208 : }
26209 :
26210 :
26211 0 : SWIGINTERN PyObject *_wrap_layerObj_tileitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26212 : PyObject *resultobj = 0;
26213 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26214 : char *arg2 = (char *) 0 ;
26215 0 : void *argp1 = 0 ;
26216 : int res1 = 0 ;
26217 : int res2 ;
26218 0 : char *buf2 = 0 ;
26219 0 : int alloc2 = 0 ;
26220 0 : PyObject * obj0 = 0 ;
26221 0 : PyObject * obj1 = 0 ;
26222 :
26223 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tileitem_set",&obj0,&obj1)) SWIG_fail;
26224 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26225 0 : if (!SWIG_IsOK(res1)) {
26226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
26227 : }
26228 0 : arg1 = (struct layerObj *)(argp1);
26229 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26230 0 : if (!SWIG_IsOK(res2)) {
26231 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tileitem_set" "', argument " "2"" of type '" "char *""'");
26232 : }
26233 0 : arg2 = (char *)(buf2);
26234 : {
26235 0 : if (arg1->tileitem) free((char*)arg1->tileitem);
26236 0 : if (arg2) {
26237 0 : arg1->tileitem = (char *) malloc(strlen(arg2)+1);
26238 : strcpy((char*)arg1->tileitem,arg2);
26239 : } else {
26240 0 : arg1->tileitem = 0;
26241 : }
26242 : }
26243 : resultobj = SWIG_Py_Void();
26244 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26245 : return resultobj;
26246 0 : fail:
26247 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26248 : return NULL;
26249 : }
26250 :
26251 :
26252 0 : SWIGINTERN PyObject *_wrap_layerObj_tileitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26253 : PyObject *resultobj = 0;
26254 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26255 0 : void *argp1 = 0 ;
26256 : int res1 = 0 ;
26257 0 : PyObject * obj0 = 0 ;
26258 : char *result = 0 ;
26259 :
26260 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tileitem_get",&obj0)) SWIG_fail;
26261 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26262 0 : if (!SWIG_IsOK(res1)) {
26263 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
26264 : }
26265 0 : arg1 = (struct layerObj *)(argp1);
26266 0 : result = (char *) ((arg1)->tileitem);
26267 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26268 0 : return resultobj;
26269 0 : fail:
26270 : return NULL;
26271 : }
26272 :
26273 :
26274 0 : SWIGINTERN PyObject *_wrap_layerObj_tileindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26275 : PyObject *resultobj = 0;
26276 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26277 : char *arg2 = (char *) 0 ;
26278 0 : void *argp1 = 0 ;
26279 : int res1 = 0 ;
26280 : int res2 ;
26281 0 : char *buf2 = 0 ;
26282 0 : int alloc2 = 0 ;
26283 0 : PyObject * obj0 = 0 ;
26284 0 : PyObject * obj1 = 0 ;
26285 :
26286 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tileindex_set",&obj0,&obj1)) SWIG_fail;
26287 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26288 0 : if (!SWIG_IsOK(res1)) {
26289 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileindex_set" "', argument " "1"" of type '" "struct layerObj *""'");
26290 : }
26291 0 : arg1 = (struct layerObj *)(argp1);
26292 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26293 0 : if (!SWIG_IsOK(res2)) {
26294 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tileindex_set" "', argument " "2"" of type '" "char *""'");
26295 : }
26296 0 : arg2 = (char *)(buf2);
26297 : {
26298 0 : if (arg1->tileindex) free((char*)arg1->tileindex);
26299 0 : if (arg2) {
26300 0 : arg1->tileindex = (char *) malloc(strlen(arg2)+1);
26301 : strcpy((char*)arg1->tileindex,arg2);
26302 : } else {
26303 0 : arg1->tileindex = 0;
26304 : }
26305 : }
26306 : resultobj = SWIG_Py_Void();
26307 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26308 : return resultobj;
26309 0 : fail:
26310 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26311 : return NULL;
26312 : }
26313 :
26314 :
26315 0 : SWIGINTERN PyObject *_wrap_layerObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26316 : PyObject *resultobj = 0;
26317 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26318 0 : void *argp1 = 0 ;
26319 : int res1 = 0 ;
26320 0 : PyObject * obj0 = 0 ;
26321 : char *result = 0 ;
26322 :
26323 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tileindex_get",&obj0)) SWIG_fail;
26324 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26325 0 : if (!SWIG_IsOK(res1)) {
26326 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tileindex_get" "', argument " "1"" of type '" "struct layerObj *""'");
26327 : }
26328 0 : arg1 = (struct layerObj *)(argp1);
26329 0 : result = (char *) ((arg1)->tileindex);
26330 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26331 0 : return resultobj;
26332 0 : fail:
26333 : return NULL;
26334 : }
26335 :
26336 :
26337 0 : SWIGINTERN PyObject *_wrap_layerObj_tilesrs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26338 : PyObject *resultobj = 0;
26339 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26340 : char *arg2 = (char *) 0 ;
26341 0 : void *argp1 = 0 ;
26342 : int res1 = 0 ;
26343 : int res2 ;
26344 0 : char *buf2 = 0 ;
26345 0 : int alloc2 = 0 ;
26346 0 : PyObject * obj0 = 0 ;
26347 0 : PyObject * obj1 = 0 ;
26348 :
26349 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_tilesrs_set",&obj0,&obj1)) SWIG_fail;
26350 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26351 0 : if (!SWIG_IsOK(res1)) {
26352 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tilesrs_set" "', argument " "1"" of type '" "struct layerObj *""'");
26353 : }
26354 0 : arg1 = (struct layerObj *)(argp1);
26355 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26356 0 : if (!SWIG_IsOK(res2)) {
26357 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_tilesrs_set" "', argument " "2"" of type '" "char *""'");
26358 : }
26359 0 : arg2 = (char *)(buf2);
26360 : {
26361 0 : if (arg1->tilesrs) free((char*)arg1->tilesrs);
26362 0 : if (arg2) {
26363 0 : arg1->tilesrs = (char *) malloc(strlen(arg2)+1);
26364 : strcpy((char*)arg1->tilesrs,arg2);
26365 : } else {
26366 0 : arg1->tilesrs = 0;
26367 : }
26368 : }
26369 : resultobj = SWIG_Py_Void();
26370 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26371 : return resultobj;
26372 0 : fail:
26373 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26374 : return NULL;
26375 : }
26376 :
26377 :
26378 0 : SWIGINTERN PyObject *_wrap_layerObj_tilesrs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26379 : PyObject *resultobj = 0;
26380 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26381 0 : void *argp1 = 0 ;
26382 : int res1 = 0 ;
26383 0 : PyObject * obj0 = 0 ;
26384 : char *result = 0 ;
26385 :
26386 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_tilesrs_get",&obj0)) SWIG_fail;
26387 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26388 0 : if (!SWIG_IsOK(res1)) {
26389 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_tilesrs_get" "', argument " "1"" of type '" "struct layerObj *""'");
26390 : }
26391 0 : arg1 = (struct layerObj *)(argp1);
26392 0 : result = (char *) ((arg1)->tilesrs);
26393 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26394 0 : return resultobj;
26395 0 : fail:
26396 : return NULL;
26397 : }
26398 :
26399 :
26400 0 : SWIGINTERN PyObject *_wrap_layerObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26401 : PyObject *resultobj = 0;
26402 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26403 : int arg2 ;
26404 0 : void *argp1 = 0 ;
26405 : int res1 = 0 ;
26406 : int val2 ;
26407 : int ecode2 = 0 ;
26408 0 : PyObject * obj0 = 0 ;
26409 0 : PyObject * obj1 = 0 ;
26410 :
26411 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_units_set",&obj0,&obj1)) SWIG_fail;
26412 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26413 0 : if (!SWIG_IsOK(res1)) {
26414 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_units_set" "', argument " "1"" of type '" "struct layerObj *""'");
26415 : }
26416 0 : arg1 = (struct layerObj *)(argp1);
26417 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26418 0 : if (!SWIG_IsOK(ecode2)) {
26419 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_units_set" "', argument " "2"" of type '" "int""'");
26420 : }
26421 : arg2 = (int)(val2);
26422 0 : if (arg1) (arg1)->units = arg2;
26423 : resultobj = SWIG_Py_Void();
26424 0 : return resultobj;
26425 0 : fail:
26426 : return NULL;
26427 : }
26428 :
26429 :
26430 0 : SWIGINTERN PyObject *_wrap_layerObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26431 : PyObject *resultobj = 0;
26432 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26433 0 : void *argp1 = 0 ;
26434 : int res1 = 0 ;
26435 0 : PyObject * obj0 = 0 ;
26436 : int result;
26437 :
26438 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_units_get",&obj0)) SWIG_fail;
26439 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26440 0 : if (!SWIG_IsOK(res1)) {
26441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_units_get" "', argument " "1"" of type '" "struct layerObj *""'");
26442 : }
26443 0 : arg1 = (struct layerObj *)(argp1);
26444 0 : result = (int) ((arg1)->units);
26445 : resultobj = SWIG_From_int((int)(result));
26446 0 : return resultobj;
26447 0 : fail:
26448 : return NULL;
26449 : }
26450 :
26451 :
26452 1 : SWIGINTERN PyObject *_wrap_layerObj_connection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26453 : PyObject *resultobj = 0;
26454 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26455 : char *arg2 = (char *) 0 ;
26456 1 : void *argp1 = 0 ;
26457 : int res1 = 0 ;
26458 : int res2 ;
26459 1 : char *buf2 = 0 ;
26460 1 : int alloc2 = 0 ;
26461 1 : PyObject * obj0 = 0 ;
26462 1 : PyObject * obj1 = 0 ;
26463 :
26464 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connection_set",&obj0,&obj1)) SWIG_fail;
26465 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26466 1 : if (!SWIG_IsOK(res1)) {
26467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connection_set" "', argument " "1"" of type '" "struct layerObj *""'");
26468 : }
26469 1 : arg1 = (struct layerObj *)(argp1);
26470 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26471 1 : if (!SWIG_IsOK(res2)) {
26472 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_connection_set" "', argument " "2"" of type '" "char *""'");
26473 : }
26474 1 : arg2 = (char *)(buf2);
26475 : {
26476 1 : if (arg1->connection) free((char*)arg1->connection);
26477 1 : if (arg2) {
26478 1 : arg1->connection = (char *) malloc(strlen(arg2)+1);
26479 : strcpy((char*)arg1->connection,arg2);
26480 : } else {
26481 0 : arg1->connection = 0;
26482 : }
26483 : }
26484 : resultobj = SWIG_Py_Void();
26485 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26486 : return resultobj;
26487 0 : fail:
26488 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26489 : return NULL;
26490 : }
26491 :
26492 :
26493 0 : SWIGINTERN PyObject *_wrap_layerObj_connection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26494 : PyObject *resultobj = 0;
26495 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26496 0 : void *argp1 = 0 ;
26497 : int res1 = 0 ;
26498 0 : PyObject * obj0 = 0 ;
26499 : char *result = 0 ;
26500 :
26501 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connection_get",&obj0)) SWIG_fail;
26502 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26503 0 : if (!SWIG_IsOK(res1)) {
26504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connection_get" "', argument " "1"" of type '" "struct layerObj *""'");
26505 : }
26506 0 : arg1 = (struct layerObj *)(argp1);
26507 0 : result = (char *) ((arg1)->connection);
26508 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26509 0 : return resultobj;
26510 0 : fail:
26511 : return NULL;
26512 : }
26513 :
26514 :
26515 0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26516 : PyObject *resultobj = 0;
26517 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26518 : char *arg2 = (char *) 0 ;
26519 0 : void *argp1 = 0 ;
26520 : int res1 = 0 ;
26521 : int res2 ;
26522 0 : char *buf2 = 0 ;
26523 0 : int alloc2 = 0 ;
26524 0 : PyObject * obj0 = 0 ;
26525 0 : PyObject * obj1 = 0 ;
26526 :
26527 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_plugin_library_set",&obj0,&obj1)) SWIG_fail;
26528 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26529 0 : if (!SWIG_IsOK(res1)) {
26530 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_set" "', argument " "1"" of type '" "struct layerObj *""'");
26531 : }
26532 0 : arg1 = (struct layerObj *)(argp1);
26533 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26534 0 : if (!SWIG_IsOK(res2)) {
26535 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_plugin_library_set" "', argument " "2"" of type '" "char *""'");
26536 : }
26537 0 : arg2 = (char *)(buf2);
26538 : {
26539 0 : if (arg1->plugin_library) free((char*)arg1->plugin_library);
26540 0 : if (arg2) {
26541 0 : arg1->plugin_library = (char *) malloc(strlen(arg2)+1);
26542 : strcpy((char*)arg1->plugin_library,arg2);
26543 : } else {
26544 0 : arg1->plugin_library = 0;
26545 : }
26546 : }
26547 : resultobj = SWIG_Py_Void();
26548 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26549 : return resultobj;
26550 0 : fail:
26551 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26552 : return NULL;
26553 : }
26554 :
26555 :
26556 0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26557 : PyObject *resultobj = 0;
26558 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26559 0 : void *argp1 = 0 ;
26560 : int res1 = 0 ;
26561 0 : PyObject * obj0 = 0 ;
26562 : char *result = 0 ;
26563 :
26564 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_plugin_library_get",&obj0)) SWIG_fail;
26565 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26566 0 : if (!SWIG_IsOK(res1)) {
26567 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_get" "', argument " "1"" of type '" "struct layerObj *""'");
26568 : }
26569 0 : arg1 = (struct layerObj *)(argp1);
26570 0 : result = (char *) ((arg1)->plugin_library);
26571 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26572 0 : return resultobj;
26573 0 : fail:
26574 : return NULL;
26575 : }
26576 :
26577 :
26578 0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_original_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26579 : PyObject *resultobj = 0;
26580 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26581 : char *arg2 = (char *) 0 ;
26582 0 : void *argp1 = 0 ;
26583 : int res1 = 0 ;
26584 : int res2 ;
26585 0 : char *buf2 = 0 ;
26586 0 : int alloc2 = 0 ;
26587 0 : PyObject * obj0 = 0 ;
26588 0 : PyObject * obj1 = 0 ;
26589 :
26590 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_plugin_library_original_set",&obj0,&obj1)) SWIG_fail;
26591 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26592 0 : if (!SWIG_IsOK(res1)) {
26593 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_original_set" "', argument " "1"" of type '" "struct layerObj *""'");
26594 : }
26595 0 : arg1 = (struct layerObj *)(argp1);
26596 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26597 0 : if (!SWIG_IsOK(res2)) {
26598 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_plugin_library_original_set" "', argument " "2"" of type '" "char *""'");
26599 : }
26600 0 : arg2 = (char *)(buf2);
26601 : {
26602 0 : if (arg1->plugin_library_original) free((char*)arg1->plugin_library_original);
26603 0 : if (arg2) {
26604 0 : arg1->plugin_library_original = (char *) malloc(strlen(arg2)+1);
26605 : strcpy((char*)arg1->plugin_library_original,arg2);
26606 : } else {
26607 0 : arg1->plugin_library_original = 0;
26608 : }
26609 : }
26610 : resultobj = SWIG_Py_Void();
26611 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26612 : return resultobj;
26613 0 : fail:
26614 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26615 : return NULL;
26616 : }
26617 :
26618 :
26619 0 : SWIGINTERN PyObject *_wrap_layerObj_plugin_library_original_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26620 : PyObject *resultobj = 0;
26621 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26622 0 : void *argp1 = 0 ;
26623 : int res1 = 0 ;
26624 0 : PyObject * obj0 = 0 ;
26625 : char *result = 0 ;
26626 :
26627 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_plugin_library_original_get",&obj0)) SWIG_fail;
26628 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26629 0 : if (!SWIG_IsOK(res1)) {
26630 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_plugin_library_original_get" "', argument " "1"" of type '" "struct layerObj *""'");
26631 : }
26632 0 : arg1 = (struct layerObj *)(argp1);
26633 0 : result = (char *) ((arg1)->plugin_library_original);
26634 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26635 0 : return resultobj;
26636 0 : fail:
26637 : return NULL;
26638 : }
26639 :
26640 :
26641 1 : SWIGINTERN PyObject *_wrap_layerObj_connectiontype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26642 : PyObject *resultobj = 0;
26643 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26644 : enum MS_CONNECTION_TYPE arg2 ;
26645 1 : void *argp1 = 0 ;
26646 : int res1 = 0 ;
26647 : int val2 ;
26648 : int ecode2 = 0 ;
26649 1 : PyObject * obj0 = 0 ;
26650 1 : PyObject * obj1 = 0 ;
26651 :
26652 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connectiontype_set",&obj0,&obj1)) SWIG_fail;
26653 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26654 1 : if (!SWIG_IsOK(res1)) {
26655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectiontype_set" "', argument " "1"" of type '" "struct layerObj *""'");
26656 : }
26657 1 : arg1 = (struct layerObj *)(argp1);
26658 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
26659 1 : if (!SWIG_IsOK(ecode2)) {
26660 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_connectiontype_set" "', argument " "2"" of type '" "enum MS_CONNECTION_TYPE""'");
26661 : }
26662 1 : arg2 = (enum MS_CONNECTION_TYPE)(val2);
26663 1 : if (arg1) (arg1)->connectiontype = arg2;
26664 : resultobj = SWIG_Py_Void();
26665 1 : return resultobj;
26666 0 : fail:
26667 : return NULL;
26668 : }
26669 :
26670 :
26671 1 : SWIGINTERN PyObject *_wrap_layerObj_connectiontype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26672 : PyObject *resultobj = 0;
26673 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26674 1 : void *argp1 = 0 ;
26675 : int res1 = 0 ;
26676 1 : PyObject * obj0 = 0 ;
26677 : enum MS_CONNECTION_TYPE result;
26678 :
26679 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connectiontype_get",&obj0)) SWIG_fail;
26680 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26681 1 : if (!SWIG_IsOK(res1)) {
26682 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectiontype_get" "', argument " "1"" of type '" "struct layerObj *""'");
26683 : }
26684 1 : arg1 = (struct layerObj *)(argp1);
26685 1 : result = (enum MS_CONNECTION_TYPE) ((arg1)->connectiontype);
26686 1 : resultobj = SWIG_From_int((int)(result));
26687 1 : return resultobj;
26688 0 : fail:
26689 : return NULL;
26690 : }
26691 :
26692 :
26693 1 : SWIGINTERN PyObject *_wrap_layerObj_numitems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26694 : PyObject *resultobj = 0;
26695 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26696 1 : void *argp1 = 0 ;
26697 : int res1 = 0 ;
26698 1 : PyObject * obj0 = 0 ;
26699 : int result;
26700 :
26701 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numitems_get",&obj0)) SWIG_fail;
26702 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26703 1 : if (!SWIG_IsOK(res1)) {
26704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numitems_get" "', argument " "1"" of type '" "struct layerObj *""'");
26705 : }
26706 1 : arg1 = (struct layerObj *)(argp1);
26707 1 : result = (int) ((arg1)->numitems);
26708 : resultobj = SWIG_From_int((int)(result));
26709 1 : return resultobj;
26710 0 : fail:
26711 : return NULL;
26712 : }
26713 :
26714 :
26715 0 : SWIGINTERN PyObject *_wrap_layerObj_bandsitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26716 : PyObject *resultobj = 0;
26717 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26718 : char *arg2 = (char *) 0 ;
26719 0 : void *argp1 = 0 ;
26720 : int res1 = 0 ;
26721 : int res2 ;
26722 0 : char *buf2 = 0 ;
26723 0 : int alloc2 = 0 ;
26724 0 : PyObject * obj0 = 0 ;
26725 0 : PyObject * obj1 = 0 ;
26726 :
26727 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_bandsitem_set",&obj0,&obj1)) SWIG_fail;
26728 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26729 0 : if (!SWIG_IsOK(res1)) {
26730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bandsitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
26731 : }
26732 0 : arg1 = (struct layerObj *)(argp1);
26733 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26734 0 : if (!SWIG_IsOK(res2)) {
26735 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_bandsitem_set" "', argument " "2"" of type '" "char *""'");
26736 : }
26737 0 : arg2 = (char *)(buf2);
26738 : {
26739 0 : if (arg1->bandsitem) free((char*)arg1->bandsitem);
26740 0 : if (arg2) {
26741 0 : arg1->bandsitem = (char *) malloc(strlen(arg2)+1);
26742 : strcpy((char*)arg1->bandsitem,arg2);
26743 : } else {
26744 0 : arg1->bandsitem = 0;
26745 : }
26746 : }
26747 : resultobj = SWIG_Py_Void();
26748 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26749 : return resultobj;
26750 0 : fail:
26751 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26752 : return NULL;
26753 : }
26754 :
26755 :
26756 0 : SWIGINTERN PyObject *_wrap_layerObj_bandsitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26757 : PyObject *resultobj = 0;
26758 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26759 0 : void *argp1 = 0 ;
26760 : int res1 = 0 ;
26761 0 : PyObject * obj0 = 0 ;
26762 : char *result = 0 ;
26763 :
26764 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_bandsitem_get",&obj0)) SWIG_fail;
26765 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26766 0 : if (!SWIG_IsOK(res1)) {
26767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bandsitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
26768 : }
26769 0 : arg1 = (struct layerObj *)(argp1);
26770 0 : result = (char *) ((arg1)->bandsitem);
26771 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26772 0 : return resultobj;
26773 0 : fail:
26774 : return NULL;
26775 : }
26776 :
26777 :
26778 1 : SWIGINTERN PyObject *_wrap_layerObj_filteritem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26779 : PyObject *resultobj = 0;
26780 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26781 : char *arg2 = (char *) 0 ;
26782 1 : void *argp1 = 0 ;
26783 : int res1 = 0 ;
26784 : int res2 ;
26785 1 : char *buf2 = 0 ;
26786 1 : int alloc2 = 0 ;
26787 1 : PyObject * obj0 = 0 ;
26788 1 : PyObject * obj1 = 0 ;
26789 :
26790 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_filteritem_set",&obj0,&obj1)) SWIG_fail;
26791 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26792 1 : if (!SWIG_IsOK(res1)) {
26793 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_filteritem_set" "', argument " "1"" of type '" "struct layerObj *""'");
26794 : }
26795 1 : arg1 = (struct layerObj *)(argp1);
26796 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26797 1 : if (!SWIG_IsOK(res2)) {
26798 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_filteritem_set" "', argument " "2"" of type '" "char *""'");
26799 : }
26800 1 : arg2 = (char *)(buf2);
26801 : {
26802 1 : if (arg1->filteritem) free((char*)arg1->filteritem);
26803 1 : if (arg2) {
26804 1 : arg1->filteritem = (char *) malloc(strlen(arg2)+1);
26805 : strcpy((char*)arg1->filteritem,arg2);
26806 : } else {
26807 0 : arg1->filteritem = 0;
26808 : }
26809 : }
26810 : resultobj = SWIG_Py_Void();
26811 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26812 : return resultobj;
26813 0 : fail:
26814 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26815 : return NULL;
26816 : }
26817 :
26818 :
26819 0 : SWIGINTERN PyObject *_wrap_layerObj_filteritem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26820 : PyObject *resultobj = 0;
26821 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26822 0 : void *argp1 = 0 ;
26823 : int res1 = 0 ;
26824 0 : PyObject * obj0 = 0 ;
26825 : char *result = 0 ;
26826 :
26827 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_filteritem_get",&obj0)) SWIG_fail;
26828 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26829 0 : if (!SWIG_IsOK(res1)) {
26830 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_filteritem_get" "', argument " "1"" of type '" "struct layerObj *""'");
26831 : }
26832 0 : arg1 = (struct layerObj *)(argp1);
26833 0 : result = (char *) ((arg1)->filteritem);
26834 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26835 0 : return resultobj;
26836 0 : fail:
26837 : return NULL;
26838 : }
26839 :
26840 :
26841 0 : SWIGINTERN PyObject *_wrap_layerObj_styleitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 : PyObject *resultobj = 0;
26843 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26844 : char *arg2 = (char *) 0 ;
26845 0 : void *argp1 = 0 ;
26846 : int res1 = 0 ;
26847 : int res2 ;
26848 0 : char *buf2 = 0 ;
26849 0 : int alloc2 = 0 ;
26850 0 : PyObject * obj0 = 0 ;
26851 0 : PyObject * obj1 = 0 ;
26852 :
26853 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_styleitem_set",&obj0,&obj1)) SWIG_fail;
26854 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26855 0 : if (!SWIG_IsOK(res1)) {
26856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_styleitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
26857 : }
26858 0 : arg1 = (struct layerObj *)(argp1);
26859 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26860 0 : if (!SWIG_IsOK(res2)) {
26861 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_styleitem_set" "', argument " "2"" of type '" "char *""'");
26862 : }
26863 0 : arg2 = (char *)(buf2);
26864 : {
26865 0 : if (arg1->styleitem) free((char*)arg1->styleitem);
26866 0 : if (arg2) {
26867 0 : arg1->styleitem = (char *) malloc(strlen(arg2)+1);
26868 : strcpy((char*)arg1->styleitem,arg2);
26869 : } else {
26870 0 : arg1->styleitem = 0;
26871 : }
26872 : }
26873 : resultobj = SWIG_Py_Void();
26874 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26875 : return resultobj;
26876 0 : fail:
26877 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26878 : return NULL;
26879 : }
26880 :
26881 :
26882 0 : SWIGINTERN PyObject *_wrap_layerObj_styleitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26883 : PyObject *resultobj = 0;
26884 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26885 0 : void *argp1 = 0 ;
26886 : int res1 = 0 ;
26887 0 : PyObject * obj0 = 0 ;
26888 : char *result = 0 ;
26889 :
26890 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_styleitem_get",&obj0)) SWIG_fail;
26891 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26892 0 : if (!SWIG_IsOK(res1)) {
26893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_styleitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
26894 : }
26895 0 : arg1 = (struct layerObj *)(argp1);
26896 0 : result = (char *) ((arg1)->styleitem);
26897 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26898 0 : return resultobj;
26899 0 : fail:
26900 : return NULL;
26901 : }
26902 :
26903 :
26904 0 : SWIGINTERN PyObject *_wrap_layerObj_requires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26905 : PyObject *resultobj = 0;
26906 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26907 : char *arg2 = (char *) 0 ;
26908 0 : void *argp1 = 0 ;
26909 : int res1 = 0 ;
26910 : int res2 ;
26911 0 : char *buf2 = 0 ;
26912 0 : int alloc2 = 0 ;
26913 0 : PyObject * obj0 = 0 ;
26914 0 : PyObject * obj1 = 0 ;
26915 :
26916 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_requires_set",&obj0,&obj1)) SWIG_fail;
26917 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26918 0 : if (!SWIG_IsOK(res1)) {
26919 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_requires_set" "', argument " "1"" of type '" "struct layerObj *""'");
26920 : }
26921 0 : arg1 = (struct layerObj *)(argp1);
26922 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26923 0 : if (!SWIG_IsOK(res2)) {
26924 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_requires_set" "', argument " "2"" of type '" "char *""'");
26925 : }
26926 0 : arg2 = (char *)(buf2);
26927 : {
26928 0 : if (arg1->requires) free((char*)arg1->requires);
26929 0 : if (arg2) {
26930 0 : arg1->requires = (char *) malloc(strlen(arg2)+1);
26931 : strcpy((char*)arg1->requires,arg2);
26932 : } else {
26933 0 : arg1->requires = 0;
26934 : }
26935 : }
26936 : resultobj = SWIG_Py_Void();
26937 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26938 : return resultobj;
26939 0 : fail:
26940 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
26941 : return NULL;
26942 : }
26943 :
26944 :
26945 0 : SWIGINTERN PyObject *_wrap_layerObj_requires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26946 : PyObject *resultobj = 0;
26947 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26948 0 : void *argp1 = 0 ;
26949 : int res1 = 0 ;
26950 0 : PyObject * obj0 = 0 ;
26951 : char *result = 0 ;
26952 :
26953 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_requires_get",&obj0)) SWIG_fail;
26954 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26955 0 : if (!SWIG_IsOK(res1)) {
26956 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_requires_get" "', argument " "1"" of type '" "struct layerObj *""'");
26957 : }
26958 0 : arg1 = (struct layerObj *)(argp1);
26959 0 : result = (char *) ((arg1)->requires);
26960 0 : resultobj = SWIG_FromCharPtr((const char *)result);
26961 0 : return resultobj;
26962 0 : fail:
26963 : return NULL;
26964 : }
26965 :
26966 :
26967 0 : SWIGINTERN PyObject *_wrap_layerObj_labelrequires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26968 : PyObject *resultobj = 0;
26969 : struct layerObj *arg1 = (struct layerObj *) 0 ;
26970 : char *arg2 = (char *) 0 ;
26971 0 : void *argp1 = 0 ;
26972 : int res1 = 0 ;
26973 : int res2 ;
26974 0 : char *buf2 = 0 ;
26975 0 : int alloc2 = 0 ;
26976 0 : PyObject * obj0 = 0 ;
26977 0 : PyObject * obj1 = 0 ;
26978 :
26979 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_labelrequires_set",&obj0,&obj1)) SWIG_fail;
26980 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
26981 0 : if (!SWIG_IsOK(res1)) {
26982 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelrequires_set" "', argument " "1"" of type '" "struct layerObj *""'");
26983 : }
26984 0 : arg1 = (struct layerObj *)(argp1);
26985 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
26986 0 : if (!SWIG_IsOK(res2)) {
26987 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_labelrequires_set" "', argument " "2"" of type '" "char *""'");
26988 : }
26989 0 : arg2 = (char *)(buf2);
26990 : {
26991 0 : if (arg1->labelrequires) free((char*)arg1->labelrequires);
26992 0 : if (arg2) {
26993 0 : arg1->labelrequires = (char *) malloc(strlen(arg2)+1);
26994 : strcpy((char*)arg1->labelrequires,arg2);
26995 : } else {
26996 0 : arg1->labelrequires = 0;
26997 : }
26998 : }
26999 : resultobj = SWIG_Py_Void();
27000 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27001 : return resultobj;
27002 0 : fail:
27003 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27004 : return NULL;
27005 : }
27006 :
27007 :
27008 0 : SWIGINTERN PyObject *_wrap_layerObj_labelrequires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27009 : PyObject *resultobj = 0;
27010 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27011 0 : void *argp1 = 0 ;
27012 : int res1 = 0 ;
27013 0 : PyObject * obj0 = 0 ;
27014 : char *result = 0 ;
27015 :
27016 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_labelrequires_get",&obj0)) SWIG_fail;
27017 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27018 0 : if (!SWIG_IsOK(res1)) {
27019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_labelrequires_get" "', argument " "1"" of type '" "struct layerObj *""'");
27020 : }
27021 0 : arg1 = (struct layerObj *)(argp1);
27022 0 : result = (char *) ((arg1)->labelrequires);
27023 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27024 0 : return resultobj;
27025 0 : fail:
27026 : return NULL;
27027 : }
27028 :
27029 :
27030 1 : SWIGINTERN PyObject *_wrap_layerObj_metadata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 : PyObject *resultobj = 0;
27032 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27033 1 : void *argp1 = 0 ;
27034 : int res1 = 0 ;
27035 1 : PyObject * obj0 = 0 ;
27036 : hashTableObj *result = 0 ;
27037 :
27038 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_metadata_get",&obj0)) SWIG_fail;
27039 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27040 1 : if (!SWIG_IsOK(res1)) {
27041 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_metadata_get" "', argument " "1"" of type '" "struct layerObj *""'");
27042 : }
27043 1 : arg1 = (struct layerObj *)(argp1);
27044 1 : result = (hashTableObj *)& ((arg1)->metadata);
27045 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
27046 1 : return resultobj;
27047 0 : fail:
27048 : return NULL;
27049 : }
27050 :
27051 :
27052 0 : SWIGINTERN PyObject *_wrap_layerObj_validation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27053 : PyObject *resultobj = 0;
27054 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27055 0 : void *argp1 = 0 ;
27056 : int res1 = 0 ;
27057 0 : PyObject * obj0 = 0 ;
27058 : hashTableObj *result = 0 ;
27059 :
27060 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_validation_get",&obj0)) SWIG_fail;
27061 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27062 0 : if (!SWIG_IsOK(res1)) {
27063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_validation_get" "', argument " "1"" of type '" "struct layerObj *""'");
27064 : }
27065 0 : arg1 = (struct layerObj *)(argp1);
27066 0 : result = (hashTableObj *)& ((arg1)->validation);
27067 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
27068 0 : return resultobj;
27069 0 : fail:
27070 : return NULL;
27071 : }
27072 :
27073 :
27074 0 : SWIGINTERN PyObject *_wrap_layerObj_bindvals_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27075 : PyObject *resultobj = 0;
27076 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27077 0 : void *argp1 = 0 ;
27078 : int res1 = 0 ;
27079 0 : PyObject * obj0 = 0 ;
27080 : hashTableObj *result = 0 ;
27081 :
27082 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_bindvals_get",&obj0)) SWIG_fail;
27083 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27084 0 : if (!SWIG_IsOK(res1)) {
27085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_bindvals_get" "', argument " "1"" of type '" "struct layerObj *""'");
27086 : }
27087 0 : arg1 = (struct layerObj *)(argp1);
27088 0 : result = (hashTableObj *)& ((arg1)->bindvals);
27089 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
27090 0 : return resultobj;
27091 0 : fail:
27092 : return NULL;
27093 : }
27094 :
27095 :
27096 0 : SWIGINTERN PyObject *_wrap_layerObj_cluster_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27097 : PyObject *resultobj = 0;
27098 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27099 0 : void *argp1 = 0 ;
27100 : int res1 = 0 ;
27101 0 : PyObject * obj0 = 0 ;
27102 : clusterObj *result = 0 ;
27103 :
27104 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_cluster_get",&obj0)) SWIG_fail;
27105 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27106 0 : if (!SWIG_IsOK(res1)) {
27107 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_cluster_get" "', argument " "1"" of type '" "struct layerObj *""'");
27108 : }
27109 0 : arg1 = (struct layerObj *)(argp1);
27110 0 : result = (clusterObj *)& ((arg1)->cluster);
27111 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_clusterObj, 0 | 0 );
27112 0 : return resultobj;
27113 0 : fail:
27114 : return NULL;
27115 : }
27116 :
27117 :
27118 0 : SWIGINTERN PyObject *_wrap_layerObj_dump_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27119 : PyObject *resultobj = 0;
27120 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27121 : int arg2 ;
27122 0 : void *argp1 = 0 ;
27123 : int res1 = 0 ;
27124 : int val2 ;
27125 : int ecode2 = 0 ;
27126 0 : PyObject * obj0 = 0 ;
27127 0 : PyObject * obj1 = 0 ;
27128 :
27129 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_dump_set",&obj0,&obj1)) SWIG_fail;
27130 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27131 0 : if (!SWIG_IsOK(res1)) {
27132 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_dump_set" "', argument " "1"" of type '" "struct layerObj *""'");
27133 : }
27134 0 : arg1 = (struct layerObj *)(argp1);
27135 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27136 0 : if (!SWIG_IsOK(ecode2)) {
27137 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_dump_set" "', argument " "2"" of type '" "int""'");
27138 : }
27139 : arg2 = (int)(val2);
27140 0 : if (arg1) (arg1)->dump = arg2;
27141 : resultobj = SWIG_Py_Void();
27142 0 : return resultobj;
27143 0 : fail:
27144 : return NULL;
27145 : }
27146 :
27147 :
27148 0 : SWIGINTERN PyObject *_wrap_layerObj_dump_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27149 : PyObject *resultobj = 0;
27150 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27151 0 : void *argp1 = 0 ;
27152 : int res1 = 0 ;
27153 0 : PyObject * obj0 = 0 ;
27154 : int result;
27155 :
27156 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_dump_get",&obj0)) SWIG_fail;
27157 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27158 0 : if (!SWIG_IsOK(res1)) {
27159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_dump_get" "', argument " "1"" of type '" "struct layerObj *""'");
27160 : }
27161 0 : arg1 = (struct layerObj *)(argp1);
27162 0 : result = (int) ((arg1)->dump);
27163 : resultobj = SWIG_From_int((int)(result));
27164 0 : return resultobj;
27165 0 : fail:
27166 : return NULL;
27167 : }
27168 :
27169 :
27170 1 : SWIGINTERN PyObject *_wrap_layerObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27171 : PyObject *resultobj = 0;
27172 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27173 : int arg2 ;
27174 1 : void *argp1 = 0 ;
27175 : int res1 = 0 ;
27176 : int val2 ;
27177 : int ecode2 = 0 ;
27178 1 : PyObject * obj0 = 0 ;
27179 1 : PyObject * obj1 = 0 ;
27180 :
27181 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_debug_set",&obj0,&obj1)) SWIG_fail;
27182 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27183 1 : if (!SWIG_IsOK(res1)) {
27184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_debug_set" "', argument " "1"" of type '" "struct layerObj *""'");
27185 : }
27186 1 : arg1 = (struct layerObj *)(argp1);
27187 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27188 1 : if (!SWIG_IsOK(ecode2)) {
27189 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_debug_set" "', argument " "2"" of type '" "int""'");
27190 : }
27191 : arg2 = (int)(val2);
27192 1 : if (arg1) (arg1)->debug = arg2;
27193 : resultobj = SWIG_Py_Void();
27194 1 : return resultobj;
27195 0 : fail:
27196 : return NULL;
27197 : }
27198 :
27199 :
27200 0 : SWIGINTERN PyObject *_wrap_layerObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27201 : PyObject *resultobj = 0;
27202 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27203 0 : void *argp1 = 0 ;
27204 : int res1 = 0 ;
27205 0 : PyObject * obj0 = 0 ;
27206 : int result;
27207 :
27208 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_debug_get",&obj0)) SWIG_fail;
27209 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27210 0 : if (!SWIG_IsOK(res1)) {
27211 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_debug_get" "', argument " "1"" of type '" "struct layerObj *""'");
27212 : }
27213 0 : arg1 = (struct layerObj *)(argp1);
27214 0 : result = (int) ((arg1)->debug);
27215 : resultobj = SWIG_From_int((int)(result));
27216 0 : return resultobj;
27217 0 : fail:
27218 : return NULL;
27219 : }
27220 :
27221 :
27222 1 : SWIGINTERN PyObject *_wrap_layerObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27223 : PyObject *resultobj = 0;
27224 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27225 1 : void *argp1 = 0 ;
27226 : int res1 = 0 ;
27227 1 : PyObject * obj0 = 0 ;
27228 : rectObj *result = 0 ;
27229 :
27230 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_extent_get",&obj0)) SWIG_fail;
27231 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27232 1 : if (!SWIG_IsOK(res1)) {
27233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_extent_get" "', argument " "1"" of type '" "struct layerObj *""'");
27234 : }
27235 1 : arg1 = (struct layerObj *)(argp1);
27236 1 : result = (rectObj *)& ((arg1)->extent);
27237 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
27238 1 : return resultobj;
27239 0 : fail:
27240 : return NULL;
27241 : }
27242 :
27243 :
27244 1 : SWIGINTERN PyObject *_wrap_layerObj_numprocessing_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27245 : PyObject *resultobj = 0;
27246 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27247 1 : void *argp1 = 0 ;
27248 : int res1 = 0 ;
27249 1 : PyObject * obj0 = 0 ;
27250 : int result;
27251 :
27252 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numprocessing_get",&obj0)) SWIG_fail;
27253 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27254 1 : if (!SWIG_IsOK(res1)) {
27255 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numprocessing_get" "', argument " "1"" of type '" "struct layerObj *""'");
27256 : }
27257 1 : arg1 = (struct layerObj *)(argp1);
27258 1 : result = (int) ((arg1)->numprocessing);
27259 : resultobj = SWIG_From_int((int)(result));
27260 1 : return resultobj;
27261 0 : fail:
27262 : return NULL;
27263 : }
27264 :
27265 :
27266 0 : SWIGINTERN PyObject *_wrap_layerObj_numjoins_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27267 : PyObject *resultobj = 0;
27268 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27269 0 : void *argp1 = 0 ;
27270 : int res1 = 0 ;
27271 0 : PyObject * obj0 = 0 ;
27272 : int result;
27273 :
27274 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_numjoins_get",&obj0)) SWIG_fail;
27275 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27276 0 : if (!SWIG_IsOK(res1)) {
27277 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_numjoins_get" "', argument " "1"" of type '" "struct layerObj *""'");
27278 : }
27279 0 : arg1 = (struct layerObj *)(argp1);
27280 0 : result = (int) ((arg1)->numjoins);
27281 : resultobj = SWIG_From_int((int)(result));
27282 0 : return resultobj;
27283 0 : fail:
27284 : return NULL;
27285 : }
27286 :
27287 :
27288 0 : SWIGINTERN PyObject *_wrap_layerObj_classgroup_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27289 : PyObject *resultobj = 0;
27290 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27291 : char *arg2 = (char *) 0 ;
27292 0 : void *argp1 = 0 ;
27293 : int res1 = 0 ;
27294 : int res2 ;
27295 0 : char *buf2 = 0 ;
27296 0 : int alloc2 = 0 ;
27297 0 : PyObject * obj0 = 0 ;
27298 0 : PyObject * obj1 = 0 ;
27299 :
27300 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_classgroup_set",&obj0,&obj1)) SWIG_fail;
27301 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27302 0 : if (!SWIG_IsOK(res1)) {
27303 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classgroup_set" "', argument " "1"" of type '" "struct layerObj *""'");
27304 : }
27305 0 : arg1 = (struct layerObj *)(argp1);
27306 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27307 0 : if (!SWIG_IsOK(res2)) {
27308 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_classgroup_set" "', argument " "2"" of type '" "char *""'");
27309 : }
27310 0 : arg2 = (char *)(buf2);
27311 : {
27312 0 : if (arg1->classgroup) free((char*)arg1->classgroup);
27313 0 : if (arg2) {
27314 0 : arg1->classgroup = (char *) malloc(strlen(arg2)+1);
27315 : strcpy((char*)arg1->classgroup,arg2);
27316 : } else {
27317 0 : arg1->classgroup = 0;
27318 : }
27319 : }
27320 : resultobj = SWIG_Py_Void();
27321 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27322 : return resultobj;
27323 0 : fail:
27324 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27325 : return NULL;
27326 : }
27327 :
27328 :
27329 0 : SWIGINTERN PyObject *_wrap_layerObj_classgroup_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27330 : PyObject *resultobj = 0;
27331 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27332 0 : void *argp1 = 0 ;
27333 : int res1 = 0 ;
27334 0 : PyObject * obj0 = 0 ;
27335 : char *result = 0 ;
27336 :
27337 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_classgroup_get",&obj0)) SWIG_fail;
27338 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27339 0 : if (!SWIG_IsOK(res1)) {
27340 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_classgroup_get" "', argument " "1"" of type '" "struct layerObj *""'");
27341 : }
27342 0 : arg1 = (struct layerObj *)(argp1);
27343 0 : result = (char *) ((arg1)->classgroup);
27344 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27345 0 : return resultobj;
27346 0 : fail:
27347 : return NULL;
27348 : }
27349 :
27350 :
27351 0 : SWIGINTERN PyObject *_wrap_layerObj_mask_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27352 : PyObject *resultobj = 0;
27353 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27354 : char *arg2 = (char *) 0 ;
27355 0 : void *argp1 = 0 ;
27356 : int res1 = 0 ;
27357 : int res2 ;
27358 0 : char *buf2 = 0 ;
27359 0 : int alloc2 = 0 ;
27360 0 : PyObject * obj0 = 0 ;
27361 0 : PyObject * obj1 = 0 ;
27362 :
27363 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_mask_set",&obj0,&obj1)) SWIG_fail;
27364 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27365 0 : if (!SWIG_IsOK(res1)) {
27366 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mask_set" "', argument " "1"" of type '" "struct layerObj *""'");
27367 : }
27368 0 : arg1 = (struct layerObj *)(argp1);
27369 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27370 0 : if (!SWIG_IsOK(res2)) {
27371 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_mask_set" "', argument " "2"" of type '" "char *""'");
27372 : }
27373 0 : arg2 = (char *)(buf2);
27374 : {
27375 0 : if (arg1->mask) free((char*)arg1->mask);
27376 0 : if (arg2) {
27377 0 : arg1->mask = (char *) malloc(strlen(arg2)+1);
27378 : strcpy((char*)arg1->mask,arg2);
27379 : } else {
27380 0 : arg1->mask = 0;
27381 : }
27382 : }
27383 : resultobj = SWIG_Py_Void();
27384 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27385 : return resultobj;
27386 0 : fail:
27387 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27388 : return NULL;
27389 : }
27390 :
27391 :
27392 0 : SWIGINTERN PyObject *_wrap_layerObj_mask_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27393 : PyObject *resultobj = 0;
27394 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27395 0 : void *argp1 = 0 ;
27396 : int res1 = 0 ;
27397 0 : PyObject * obj0 = 0 ;
27398 : char *result = 0 ;
27399 :
27400 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_mask_get",&obj0)) SWIG_fail;
27401 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27402 0 : if (!SWIG_IsOK(res1)) {
27403 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_mask_get" "', argument " "1"" of type '" "struct layerObj *""'");
27404 : }
27405 0 : arg1 = (struct layerObj *)(argp1);
27406 0 : result = (char *) ((arg1)->mask);
27407 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27408 0 : return resultobj;
27409 0 : fail:
27410 : return NULL;
27411 : }
27412 :
27413 :
27414 0 : SWIGINTERN PyObject *_wrap_layerObj_encoding_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27415 : PyObject *resultobj = 0;
27416 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27417 : char *arg2 = (char *) 0 ;
27418 0 : void *argp1 = 0 ;
27419 : int res1 = 0 ;
27420 : int res2 ;
27421 0 : char *buf2 = 0 ;
27422 0 : int alloc2 = 0 ;
27423 0 : PyObject * obj0 = 0 ;
27424 0 : PyObject * obj1 = 0 ;
27425 :
27426 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_encoding_set",&obj0,&obj1)) SWIG_fail;
27427 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27428 0 : if (!SWIG_IsOK(res1)) {
27429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_encoding_set" "', argument " "1"" of type '" "struct layerObj *""'");
27430 : }
27431 0 : arg1 = (struct layerObj *)(argp1);
27432 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27433 0 : if (!SWIG_IsOK(res2)) {
27434 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_encoding_set" "', argument " "2"" of type '" "char *""'");
27435 : }
27436 0 : arg2 = (char *)(buf2);
27437 : {
27438 0 : if (arg1->encoding) free((char*)arg1->encoding);
27439 0 : if (arg2) {
27440 0 : arg1->encoding = (char *) malloc(strlen(arg2)+1);
27441 : strcpy((char*)arg1->encoding,arg2);
27442 : } else {
27443 0 : arg1->encoding = 0;
27444 : }
27445 : }
27446 : resultobj = SWIG_Py_Void();
27447 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27448 : return resultobj;
27449 0 : fail:
27450 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27451 : return NULL;
27452 : }
27453 :
27454 :
27455 0 : SWIGINTERN PyObject *_wrap_layerObj_encoding_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27456 : PyObject *resultobj = 0;
27457 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27458 0 : void *argp1 = 0 ;
27459 : int res1 = 0 ;
27460 0 : PyObject * obj0 = 0 ;
27461 : char *result = 0 ;
27462 :
27463 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_encoding_get",&obj0)) SWIG_fail;
27464 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27465 0 : if (!SWIG_IsOK(res1)) {
27466 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_encoding_get" "', argument " "1"" of type '" "struct layerObj *""'");
27467 : }
27468 0 : arg1 = (struct layerObj *)(argp1);
27469 0 : result = (char *) ((arg1)->encoding);
27470 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27471 0 : return resultobj;
27472 0 : fail:
27473 : return NULL;
27474 : }
27475 :
27476 :
27477 0 : SWIGINTERN PyObject *_wrap_layerObj_utfitem_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27478 : PyObject *resultobj = 0;
27479 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27480 : char *arg2 = (char *) 0 ;
27481 0 : void *argp1 = 0 ;
27482 : int res1 = 0 ;
27483 : int res2 ;
27484 0 : char *buf2 = 0 ;
27485 0 : int alloc2 = 0 ;
27486 0 : PyObject * obj0 = 0 ;
27487 0 : PyObject * obj1 = 0 ;
27488 :
27489 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfitem_set",&obj0,&obj1)) SWIG_fail;
27490 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27491 0 : if (!SWIG_IsOK(res1)) {
27492 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitem_set" "', argument " "1"" of type '" "struct layerObj *""'");
27493 : }
27494 0 : arg1 = (struct layerObj *)(argp1);
27495 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27496 0 : if (!SWIG_IsOK(res2)) {
27497 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_utfitem_set" "', argument " "2"" of type '" "char *""'");
27498 : }
27499 0 : arg2 = (char *)(buf2);
27500 : {
27501 0 : if (arg1->utfitem) free((char*)arg1->utfitem);
27502 0 : if (arg2) {
27503 0 : arg1->utfitem = (char *) malloc(strlen(arg2)+1);
27504 : strcpy((char*)arg1->utfitem,arg2);
27505 : } else {
27506 0 : arg1->utfitem = 0;
27507 : }
27508 : }
27509 : resultobj = SWIG_Py_Void();
27510 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27511 : return resultobj;
27512 0 : fail:
27513 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
27514 : return NULL;
27515 : }
27516 :
27517 :
27518 0 : SWIGINTERN PyObject *_wrap_layerObj_utfitem_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27519 : PyObject *resultobj = 0;
27520 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27521 0 : void *argp1 = 0 ;
27522 : int res1 = 0 ;
27523 0 : PyObject * obj0 = 0 ;
27524 : char *result = 0 ;
27525 :
27526 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfitem_get",&obj0)) SWIG_fail;
27527 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27528 0 : if (!SWIG_IsOK(res1)) {
27529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitem_get" "', argument " "1"" of type '" "struct layerObj *""'");
27530 : }
27531 0 : arg1 = (struct layerObj *)(argp1);
27532 0 : result = (char *) ((arg1)->utfitem);
27533 0 : resultobj = SWIG_FromCharPtr((const char *)result);
27534 0 : return resultobj;
27535 0 : fail:
27536 : return NULL;
27537 : }
27538 :
27539 :
27540 0 : SWIGINTERN PyObject *_wrap_layerObj_utfitemindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27541 : PyObject *resultobj = 0;
27542 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27543 : int arg2 ;
27544 0 : void *argp1 = 0 ;
27545 : int res1 = 0 ;
27546 : int val2 ;
27547 : int ecode2 = 0 ;
27548 0 : PyObject * obj0 = 0 ;
27549 0 : PyObject * obj1 = 0 ;
27550 :
27551 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfitemindex_set",&obj0,&obj1)) SWIG_fail;
27552 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27553 0 : if (!SWIG_IsOK(res1)) {
27554 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitemindex_set" "', argument " "1"" of type '" "struct layerObj *""'");
27555 : }
27556 0 : arg1 = (struct layerObj *)(argp1);
27557 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27558 0 : if (!SWIG_IsOK(ecode2)) {
27559 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_utfitemindex_set" "', argument " "2"" of type '" "int""'");
27560 : }
27561 : arg2 = (int)(val2);
27562 0 : if (arg1) (arg1)->utfitemindex = arg2;
27563 : resultobj = SWIG_Py_Void();
27564 0 : return resultobj;
27565 0 : fail:
27566 : return NULL;
27567 : }
27568 :
27569 :
27570 0 : SWIGINTERN PyObject *_wrap_layerObj_utfitemindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27571 : PyObject *resultobj = 0;
27572 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27573 0 : void *argp1 = 0 ;
27574 : int res1 = 0 ;
27575 0 : PyObject * obj0 = 0 ;
27576 : int result;
27577 :
27578 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfitemindex_get",&obj0)) SWIG_fail;
27579 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27580 0 : if (!SWIG_IsOK(res1)) {
27581 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfitemindex_get" "', argument " "1"" of type '" "struct layerObj *""'");
27582 : }
27583 0 : arg1 = (struct layerObj *)(argp1);
27584 0 : result = (int) ((arg1)->utfitemindex);
27585 : resultobj = SWIG_From_int((int)(result));
27586 0 : return resultobj;
27587 0 : fail:
27588 : return NULL;
27589 : }
27590 :
27591 :
27592 0 : SWIGINTERN PyObject *_wrap_layerObj_utfdata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27593 : PyObject *resultobj = 0;
27594 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27595 : expressionObj arg2 ;
27596 0 : void *argp1 = 0 ;
27597 : int res1 = 0 ;
27598 : void *argp2 ;
27599 : int res2 = 0 ;
27600 0 : PyObject * obj0 = 0 ;
27601 0 : PyObject * obj1 = 0 ;
27602 :
27603 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_utfdata_set",&obj0,&obj1)) SWIG_fail;
27604 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27605 0 : if (!SWIG_IsOK(res1)) {
27606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfdata_set" "', argument " "1"" of type '" "struct layerObj *""'");
27607 : }
27608 0 : arg1 = (struct layerObj *)(argp1);
27609 : {
27610 0 : res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_expressionObj, 0 );
27611 0 : if (!SWIG_IsOK(res2)) {
27612 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_utfdata_set" "', argument " "2"" of type '" "expressionObj""'");
27613 : }
27614 0 : if (!argp2) {
27615 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_utfdata_set" "', argument " "2"" of type '" "expressionObj""'");
27616 : } else {
27617 0 : arg2 = *((expressionObj *)(argp2));
27618 : }
27619 : }
27620 0 : if (arg1) (arg1)->utfdata = arg2;
27621 : resultobj = SWIG_Py_Void();
27622 0 : return resultobj;
27623 0 : fail:
27624 : return NULL;
27625 : }
27626 :
27627 :
27628 0 : SWIGINTERN PyObject *_wrap_layerObj_utfdata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27629 : PyObject *resultobj = 0;
27630 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27631 0 : void *argp1 = 0 ;
27632 : int res1 = 0 ;
27633 0 : PyObject * obj0 = 0 ;
27634 : expressionObj result;
27635 :
27636 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_utfdata_get",&obj0)) SWIG_fail;
27637 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27638 0 : if (!SWIG_IsOK(res1)) {
27639 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_utfdata_get" "', argument " "1"" of type '" "struct layerObj *""'");
27640 : }
27641 0 : arg1 = (struct layerObj *)(argp1);
27642 0 : result = ((arg1)->utfdata);
27643 0 : resultobj = SWIG_NewPointerObj((expressionObj *)memcpy((expressionObj *)calloc(1,sizeof(expressionObj)),&result,sizeof(expressionObj)), SWIGTYPE_p_expressionObj, SWIG_POINTER_OWN | 0 );
27644 0 : return resultobj;
27645 0 : fail:
27646 : return NULL;
27647 : }
27648 :
27649 :
27650 0 : SWIGINTERN PyObject *_wrap_layerObj_compositer_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27651 : PyObject *resultobj = 0;
27652 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27653 : LayerCompositer *arg2 = (LayerCompositer *) 0 ;
27654 0 : void *argp1 = 0 ;
27655 : int res1 = 0 ;
27656 0 : void *argp2 = 0 ;
27657 : int res2 = 0 ;
27658 0 : PyObject * obj0 = 0 ;
27659 0 : PyObject * obj1 = 0 ;
27660 :
27661 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_compositer_set",&obj0,&obj1)) SWIG_fail;
27662 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27663 0 : if (!SWIG_IsOK(res1)) {
27664 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_compositer_set" "', argument " "1"" of type '" "struct layerObj *""'");
27665 : }
27666 0 : arg1 = (struct layerObj *)(argp1);
27667 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__LayerCompositer, SWIG_POINTER_DISOWN | 0 );
27668 0 : if (!SWIG_IsOK(res2)) {
27669 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_compositer_set" "', argument " "2"" of type '" "LayerCompositer *""'");
27670 : }
27671 0 : arg2 = (LayerCompositer *)(argp2);
27672 0 : if (arg1) (arg1)->compositer = arg2;
27673 : resultobj = SWIG_Py_Void();
27674 0 : return resultobj;
27675 0 : fail:
27676 : return NULL;
27677 : }
27678 :
27679 :
27680 0 : SWIGINTERN PyObject *_wrap_layerObj_compositer_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27681 : PyObject *resultobj = 0;
27682 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27683 0 : void *argp1 = 0 ;
27684 : int res1 = 0 ;
27685 0 : PyObject * obj0 = 0 ;
27686 : LayerCompositer *result = 0 ;
27687 :
27688 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_compositer_get",&obj0)) SWIG_fail;
27689 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27690 0 : if (!SWIG_IsOK(res1)) {
27691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_compositer_get" "', argument " "1"" of type '" "struct layerObj *""'");
27692 : }
27693 0 : arg1 = (struct layerObj *)(argp1);
27694 0 : result = (LayerCompositer *) ((arg1)->compositer);
27695 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__LayerCompositer, 0 | 0 );
27696 0 : return resultobj;
27697 0 : fail:
27698 : return NULL;
27699 : }
27700 :
27701 :
27702 0 : SWIGINTERN PyObject *_wrap_layerObj_connectionoptions_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27703 : PyObject *resultobj = 0;
27704 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27705 : hashTableObj *arg2 = (hashTableObj *) 0 ;
27706 0 : void *argp1 = 0 ;
27707 : int res1 = 0 ;
27708 0 : void *argp2 = 0 ;
27709 : int res2 = 0 ;
27710 0 : PyObject * obj0 = 0 ;
27711 0 : PyObject * obj1 = 0 ;
27712 :
27713 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_connectionoptions_set",&obj0,&obj1)) SWIG_fail;
27714 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27715 0 : if (!SWIG_IsOK(res1)) {
27716 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectionoptions_set" "', argument " "1"" of type '" "struct layerObj *""'");
27717 : }
27718 0 : arg1 = (struct layerObj *)(argp1);
27719 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_hashTableObj, 0 | 0 );
27720 0 : if (!SWIG_IsOK(res2)) {
27721 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_connectionoptions_set" "', argument " "2"" of type '" "hashTableObj *""'");
27722 : }
27723 0 : arg2 = (hashTableObj *)(argp2);
27724 0 : if (arg1) (arg1)->connectionoptions = *arg2;
27725 : resultobj = SWIG_Py_Void();
27726 0 : return resultobj;
27727 0 : fail:
27728 : return NULL;
27729 : }
27730 :
27731 :
27732 0 : SWIGINTERN PyObject *_wrap_layerObj_connectionoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27733 : PyObject *resultobj = 0;
27734 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27735 0 : void *argp1 = 0 ;
27736 : int res1 = 0 ;
27737 0 : PyObject * obj0 = 0 ;
27738 : hashTableObj *result = 0 ;
27739 :
27740 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_connectionoptions_get",&obj0)) SWIG_fail;
27741 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27742 0 : if (!SWIG_IsOK(res1)) {
27743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_connectionoptions_get" "', argument " "1"" of type '" "struct layerObj *""'");
27744 : }
27745 0 : arg1 = (struct layerObj *)(argp1);
27746 0 : result = (hashTableObj *)& ((arg1)->connectionoptions);
27747 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
27748 0 : return resultobj;
27749 0 : fail:
27750 : return NULL;
27751 : }
27752 :
27753 :
27754 1 : SWIGINTERN PyObject *_wrap_new_layerObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27755 : PyObject *resultobj = 0;
27756 : mapObj *arg1 = (mapObj *) NULL ;
27757 1 : void *argp1 = 0 ;
27758 : int res1 = 0 ;
27759 1 : PyObject * obj0 = 0 ;
27760 : struct layerObj *result = 0 ;
27761 :
27762 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_layerObj",&obj0)) SWIG_fail;
27763 1 : if (obj0) {
27764 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
27765 1 : if (!SWIG_IsOK(res1)) {
27766 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_layerObj" "', argument " "1"" of type '" "mapObj *""'");
27767 : }
27768 1 : arg1 = (mapObj *)(argp1);
27769 : }
27770 : {
27771 1 : result = (struct layerObj *)new_layerObj(arg1); {
27772 1 : errorObj *ms_error = msGetErrorObj();
27773 :
27774 1 : switch(ms_error->code) {
27775 : case MS_NOERR:
27776 : break;
27777 0 : case MS_NOTFOUND:
27778 0 : msResetErrorList();
27779 0 : break;
27780 : case -1:
27781 : break;
27782 0 : case MS_IOERR:
27783 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
27784 0 : _raise_ms_exception();
27785 0 : msResetErrorList();
27786 0 : return NULL;
27787 : }
27788 : default:
27789 0 : _raise_ms_exception();
27790 0 : msResetErrorList();
27791 0 : return NULL;
27792 : }
27793 :
27794 : }
27795 : }
27796 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_NEW | 0 );
27797 1 : return resultobj;
27798 0 : fail:
27799 : return NULL;
27800 : }
27801 :
27802 :
27803 0 : SWIGINTERN PyObject *_wrap_layerObj_setOpacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27804 : PyObject *resultobj = 0;
27805 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27806 : int arg2 ;
27807 0 : void *argp1 = 0 ;
27808 : int res1 = 0 ;
27809 : int val2 ;
27810 : int ecode2 = 0 ;
27811 0 : PyObject * obj0 = 0 ;
27812 0 : PyObject * obj1 = 0 ;
27813 :
27814 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setOpacity",&obj0,&obj1)) SWIG_fail;
27815 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27816 0 : if (!SWIG_IsOK(res1)) {
27817 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setOpacity" "', argument " "1"" of type '" "struct layerObj *""'");
27818 : }
27819 0 : arg1 = (struct layerObj *)(argp1);
27820 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
27821 0 : if (!SWIG_IsOK(ecode2)) {
27822 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setOpacity" "', argument " "2"" of type '" "int""'");
27823 : }
27824 : arg2 = (int)(val2);
27825 : {
27826 : layerObj_setOpacity(arg1,arg2); {
27827 0 : errorObj *ms_error = msGetErrorObj();
27828 :
27829 0 : switch(ms_error->code) {
27830 : case MS_NOERR:
27831 : break;
27832 0 : case MS_NOTFOUND:
27833 0 : msResetErrorList();
27834 0 : break;
27835 : case -1:
27836 : break;
27837 0 : case MS_IOERR:
27838 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
27839 0 : _raise_ms_exception();
27840 0 : msResetErrorList();
27841 0 : return NULL;
27842 : }
27843 : default:
27844 0 : _raise_ms_exception();
27845 0 : msResetErrorList();
27846 0 : return NULL;
27847 : }
27848 :
27849 : }
27850 : }
27851 : resultobj = SWIG_Py_Void();
27852 0 : return resultobj;
27853 0 : fail:
27854 : return NULL;
27855 : }
27856 :
27857 :
27858 0 : SWIGINTERN PyObject *_wrap_layerObj_getOpacity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27859 : PyObject *resultobj = 0;
27860 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27861 0 : void *argp1 = 0 ;
27862 : int res1 = 0 ;
27863 0 : PyObject * obj0 = 0 ;
27864 : int result;
27865 :
27866 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getOpacity",&obj0)) SWIG_fail;
27867 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27868 0 : if (!SWIG_IsOK(res1)) {
27869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getOpacity" "', argument " "1"" of type '" "struct layerObj *""'");
27870 : }
27871 0 : arg1 = (struct layerObj *)(argp1);
27872 : {
27873 0 : result = (int)layerObj_getOpacity(arg1); {
27874 0 : errorObj *ms_error = msGetErrorObj();
27875 :
27876 0 : switch(ms_error->code) {
27877 : case MS_NOERR:
27878 : break;
27879 0 : case MS_NOTFOUND:
27880 0 : msResetErrorList();
27881 0 : break;
27882 : case -1:
27883 : break;
27884 0 : case MS_IOERR:
27885 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
27886 0 : _raise_ms_exception();
27887 0 : msResetErrorList();
27888 0 : return NULL;
27889 : }
27890 : default:
27891 0 : _raise_ms_exception();
27892 0 : msResetErrorList();
27893 0 : return NULL;
27894 : }
27895 :
27896 : }
27897 : }
27898 : resultobj = SWIG_From_int((int)(result));
27899 0 : return resultobj;
27900 0 : fail:
27901 : return NULL;
27902 : }
27903 :
27904 :
27905 1 : SWIGINTERN PyObject *_wrap_delete_layerObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27906 : PyObject *resultobj = 0;
27907 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27908 1 : void *argp1 = 0 ;
27909 : int res1 = 0 ;
27910 1 : PyObject * obj0 = 0 ;
27911 :
27912 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_layerObj",&obj0)) SWIG_fail;
27913 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, SWIG_POINTER_DISOWN | 0 );
27914 1 : if (!SWIG_IsOK(res1)) {
27915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_layerObj" "', argument " "1"" of type '" "struct layerObj *""'");
27916 : }
27917 1 : arg1 = (struct layerObj *)(argp1);
27918 : {
27919 1 : delete_layerObj(arg1); {
27920 1 : errorObj *ms_error = msGetErrorObj();
27921 :
27922 1 : switch(ms_error->code) {
27923 : case MS_NOERR:
27924 : break;
27925 0 : case MS_NOTFOUND:
27926 0 : msResetErrorList();
27927 0 : break;
27928 : case -1:
27929 : break;
27930 0 : case MS_IOERR:
27931 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
27932 0 : _raise_ms_exception();
27933 0 : msResetErrorList();
27934 0 : return NULL;
27935 : }
27936 : default:
27937 0 : _raise_ms_exception();
27938 0 : msResetErrorList();
27939 0 : return NULL;
27940 : }
27941 :
27942 : }
27943 : }
27944 : resultobj = SWIG_Py_Void();
27945 1 : return resultobj;
27946 0 : fail:
27947 : return NULL;
27948 : }
27949 :
27950 :
27951 1 : SWIGINTERN PyObject *_wrap_layerObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27952 : PyObject *resultobj = 0;
27953 : struct layerObj *arg1 = (struct layerObj *) 0 ;
27954 1 : void *argp1 = 0 ;
27955 : int res1 = 0 ;
27956 1 : PyObject * obj0 = 0 ;
27957 : layerObj *result = 0 ;
27958 :
27959 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_clone",&obj0)) SWIG_fail;
27960 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
27961 1 : if (!SWIG_IsOK(res1)) {
27962 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_clone" "', argument " "1"" of type '" "struct layerObj *""'");
27963 : }
27964 1 : arg1 = (struct layerObj *)(argp1);
27965 : {
27966 1 : result = (layerObj *)layerObj_clone(arg1); {
27967 1 : errorObj *ms_error = msGetErrorObj();
27968 :
27969 1 : switch(ms_error->code) {
27970 : case MS_NOERR:
27971 : break;
27972 0 : case MS_NOTFOUND:
27973 0 : msResetErrorList();
27974 0 : break;
27975 : case -1:
27976 : break;
27977 0 : case MS_IOERR:
27978 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
27979 0 : _raise_ms_exception();
27980 0 : msResetErrorList();
27981 0 : return NULL;
27982 : }
27983 : default:
27984 0 : _raise_ms_exception();
27985 0 : msResetErrorList();
27986 0 : return NULL;
27987 : }
27988 :
27989 : }
27990 : }
27991 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN | 0 );
27992 1 : return resultobj;
27993 0 : fail:
27994 : return NULL;
27995 : }
27996 :
27997 :
27998 1 : SWIGINTERN PyObject *_wrap_layerObj_updateFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27999 : PyObject *resultobj = 0;
28000 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28001 : char *arg2 = (char *) 0 ;
28002 1 : void *argp1 = 0 ;
28003 : int res1 = 0 ;
28004 : int res2 ;
28005 1 : char *buf2 = 0 ;
28006 1 : int alloc2 = 0 ;
28007 1 : PyObject * obj0 = 0 ;
28008 1 : PyObject * obj1 = 0 ;
28009 : int result;
28010 :
28011 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_updateFromString",&obj0,&obj1)) SWIG_fail;
28012 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28013 1 : if (!SWIG_IsOK(res1)) {
28014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_updateFromString" "', argument " "1"" of type '" "struct layerObj *""'");
28015 : }
28016 1 : arg1 = (struct layerObj *)(argp1);
28017 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
28018 1 : if (!SWIG_IsOK(res2)) {
28019 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_updateFromString" "', argument " "2"" of type '" "char *""'");
28020 : }
28021 1 : arg2 = (char *)(buf2);
28022 : {
28023 : result = (int)layerObj_updateFromString(arg1,arg2); {
28024 1 : errorObj *ms_error = msGetErrorObj();
28025 :
28026 1 : switch(ms_error->code) {
28027 : case MS_NOERR:
28028 : break;
28029 0 : case MS_NOTFOUND:
28030 0 : msResetErrorList();
28031 0 : break;
28032 : case -1:
28033 : break;
28034 0 : case MS_IOERR:
28035 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28036 0 : _raise_ms_exception();
28037 0 : msResetErrorList();
28038 0 : return NULL;
28039 : }
28040 : default:
28041 0 : _raise_ms_exception();
28042 0 : msResetErrorList();
28043 0 : return NULL;
28044 : }
28045 :
28046 : }
28047 : }
28048 : resultobj = SWIG_From_int((int)(result));
28049 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28050 : return resultobj;
28051 0 : fail:
28052 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28053 : return NULL;
28054 : }
28055 :
28056 :
28057 0 : SWIGINTERN PyObject *_wrap_layerObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28058 : PyObject *resultobj = 0;
28059 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28060 0 : void *argp1 = 0 ;
28061 : int res1 = 0 ;
28062 0 : PyObject * obj0 = 0 ;
28063 : char *result = 0 ;
28064 :
28065 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_convertToString",&obj0)) SWIG_fail;
28066 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28067 0 : if (!SWIG_IsOK(res1)) {
28068 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_convertToString" "', argument " "1"" of type '" "struct layerObj *""'");
28069 : }
28070 0 : arg1 = (struct layerObj *)(argp1);
28071 : {
28072 : result = (char *)layerObj_convertToString(arg1); {
28073 0 : errorObj *ms_error = msGetErrorObj();
28074 :
28075 0 : switch(ms_error->code) {
28076 : case MS_NOERR:
28077 : break;
28078 0 : case MS_NOTFOUND:
28079 0 : msResetErrorList();
28080 0 : break;
28081 : case -1:
28082 : break;
28083 0 : case MS_IOERR:
28084 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28085 0 : _raise_ms_exception();
28086 0 : msResetErrorList();
28087 0 : return NULL;
28088 : }
28089 : default:
28090 0 : _raise_ms_exception();
28091 0 : msResetErrorList();
28092 0 : return NULL;
28093 : }
28094 :
28095 : }
28096 : }
28097 0 : resultobj = SWIG_FromCharPtr((const char *)result);
28098 0 : free((char*)result);
28099 0 : return resultobj;
28100 0 : fail:
28101 : return NULL;
28102 : }
28103 :
28104 :
28105 1 : SWIGINTERN PyObject *_wrap_layerObj_insertClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28106 : PyObject *resultobj = 0;
28107 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28108 : classObj *arg2 = (classObj *) 0 ;
28109 : int arg3 = (int) -1 ;
28110 1 : void *argp1 = 0 ;
28111 : int res1 = 0 ;
28112 1 : void *argp2 = 0 ;
28113 : int res2 = 0 ;
28114 : int val3 ;
28115 : int ecode3 = 0 ;
28116 1 : PyObject * obj0 = 0 ;
28117 1 : PyObject * obj1 = 0 ;
28118 1 : PyObject * obj2 = 0 ;
28119 : int result;
28120 :
28121 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:layerObj_insertClass",&obj0,&obj1,&obj2)) SWIG_fail;
28122 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28123 1 : if (!SWIG_IsOK(res1)) {
28124 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_insertClass" "', argument " "1"" of type '" "struct layerObj *""'");
28125 : }
28126 1 : arg1 = (struct layerObj *)(argp1);
28127 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_classObj, 0 | 0 );
28128 1 : if (!SWIG_IsOK(res2)) {
28129 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_insertClass" "', argument " "2"" of type '" "classObj *""'");
28130 : }
28131 1 : arg2 = (classObj *)(argp2);
28132 1 : if (obj2) {
28133 : ecode3 = SWIG_AsVal_int(obj2, &val3);
28134 1 : if (!SWIG_IsOK(ecode3)) {
28135 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_insertClass" "', argument " "3"" of type '" "int""'");
28136 : }
28137 : arg3 = (int)(val3);
28138 : }
28139 : {
28140 : result = (int)layerObj_insertClass(arg1,arg2,arg3); {
28141 1 : errorObj *ms_error = msGetErrorObj();
28142 :
28143 1 : switch(ms_error->code) {
28144 : case MS_NOERR:
28145 : break;
28146 0 : case MS_NOTFOUND:
28147 0 : msResetErrorList();
28148 0 : break;
28149 : case -1:
28150 : break;
28151 0 : case MS_IOERR:
28152 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28153 0 : _raise_ms_exception();
28154 0 : msResetErrorList();
28155 0 : return NULL;
28156 : }
28157 : default:
28158 1 : _raise_ms_exception();
28159 1 : msResetErrorList();
28160 1 : return NULL;
28161 : }
28162 :
28163 : }
28164 : }
28165 : resultobj = SWIG_From_int((int)(result));
28166 1 : return resultobj;
28167 0 : fail:
28168 : return NULL;
28169 : }
28170 :
28171 :
28172 1 : SWIGINTERN PyObject *_wrap_layerObj_removeClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28173 : PyObject *resultobj = 0;
28174 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28175 : int arg2 ;
28176 1 : void *argp1 = 0 ;
28177 : int res1 = 0 ;
28178 : int val2 ;
28179 : int ecode2 = 0 ;
28180 1 : PyObject * obj0 = 0 ;
28181 1 : PyObject * obj1 = 0 ;
28182 : classObj *result = 0 ;
28183 :
28184 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_removeClass",&obj0,&obj1)) SWIG_fail;
28185 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28186 1 : if (!SWIG_IsOK(res1)) {
28187 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_removeClass" "', argument " "1"" of type '" "struct layerObj *""'");
28188 : }
28189 1 : arg1 = (struct layerObj *)(argp1);
28190 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28191 1 : if (!SWIG_IsOK(ecode2)) {
28192 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_removeClass" "', argument " "2"" of type '" "int""'");
28193 : }
28194 : arg2 = (int)(val2);
28195 : {
28196 1 : result = (classObj *)layerObj_removeClass(arg1,arg2); {
28197 1 : errorObj *ms_error = msGetErrorObj();
28198 :
28199 1 : switch(ms_error->code) {
28200 : case MS_NOERR:
28201 : break;
28202 0 : case MS_NOTFOUND:
28203 0 : msResetErrorList();
28204 0 : break;
28205 : case -1:
28206 : break;
28207 0 : case MS_IOERR:
28208 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28209 0 : _raise_ms_exception();
28210 0 : msResetErrorList();
28211 0 : return NULL;
28212 : }
28213 : default:
28214 0 : _raise_ms_exception();
28215 0 : msResetErrorList();
28216 0 : return NULL;
28217 : }
28218 :
28219 : }
28220 : }
28221 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN | 0 );
28222 1 : return resultobj;
28223 0 : fail:
28224 : return NULL;
28225 : }
28226 :
28227 :
28228 1 : SWIGINTERN PyObject *_wrap_layerObj_open(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28229 : PyObject *resultobj = 0;
28230 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28231 1 : void *argp1 = 0 ;
28232 : int res1 = 0 ;
28233 1 : PyObject * obj0 = 0 ;
28234 : int result;
28235 :
28236 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_open",&obj0)) SWIG_fail;
28237 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28238 1 : if (!SWIG_IsOK(res1)) {
28239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_open" "', argument " "1"" of type '" "struct layerObj *""'");
28240 : }
28241 1 : arg1 = (struct layerObj *)(argp1);
28242 : {
28243 1 : result = (int)layerObj_open(arg1); {
28244 1 : errorObj *ms_error = msGetErrorObj();
28245 :
28246 1 : switch(ms_error->code) {
28247 : case MS_NOERR:
28248 : break;
28249 0 : case MS_NOTFOUND:
28250 0 : msResetErrorList();
28251 0 : break;
28252 : case -1:
28253 : break;
28254 1 : case MS_IOERR:
28255 1 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28256 1 : _raise_ms_exception();
28257 1 : msResetErrorList();
28258 1 : return NULL;
28259 : }
28260 : default:
28261 0 : _raise_ms_exception();
28262 0 : msResetErrorList();
28263 0 : return NULL;
28264 : }
28265 :
28266 : }
28267 : }
28268 : resultobj = SWIG_From_int((int)(result));
28269 1 : return resultobj;
28270 0 : fail:
28271 : return NULL;
28272 : }
28273 :
28274 :
28275 0 : SWIGINTERN PyObject *_wrap_layerObj_whichShapes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28276 : PyObject *resultobj = 0;
28277 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28278 : rectObj arg2 ;
28279 0 : void *argp1 = 0 ;
28280 : int res1 = 0 ;
28281 : void *argp2 ;
28282 : int res2 = 0 ;
28283 0 : PyObject * obj0 = 0 ;
28284 0 : PyObject * obj1 = 0 ;
28285 : int result;
28286 :
28287 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_whichShapes",&obj0,&obj1)) SWIG_fail;
28288 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28289 0 : if (!SWIG_IsOK(res1)) {
28290 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_whichShapes" "', argument " "1"" of type '" "struct layerObj *""'");
28291 : }
28292 0 : arg1 = (struct layerObj *)(argp1);
28293 : {
28294 0 : res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_rectObj, 0 );
28295 0 : if (!SWIG_IsOK(res2)) {
28296 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_whichShapes" "', argument " "2"" of type '" "rectObj""'");
28297 : }
28298 0 : if (!argp2) {
28299 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_whichShapes" "', argument " "2"" of type '" "rectObj""'");
28300 : } else {
28301 0 : arg2 = *((rectObj *)(argp2));
28302 : }
28303 : }
28304 : {
28305 0 : result = (int)layerObj_whichShapes(arg1,arg2); {
28306 0 : errorObj *ms_error = msGetErrorObj();
28307 :
28308 0 : switch(ms_error->code) {
28309 : case MS_NOERR:
28310 : break;
28311 0 : case MS_NOTFOUND:
28312 0 : msResetErrorList();
28313 0 : break;
28314 : case -1:
28315 : break;
28316 0 : case MS_IOERR:
28317 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28318 0 : _raise_ms_exception();
28319 0 : msResetErrorList();
28320 0 : return NULL;
28321 : }
28322 : default:
28323 0 : _raise_ms_exception();
28324 0 : msResetErrorList();
28325 0 : return NULL;
28326 : }
28327 :
28328 : }
28329 : }
28330 : resultobj = SWIG_From_int((int)(result));
28331 0 : return resultobj;
28332 0 : fail:
28333 : return NULL;
28334 : }
28335 :
28336 :
28337 0 : SWIGINTERN PyObject *_wrap_layerObj_nextShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28338 : PyObject *resultobj = 0;
28339 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28340 0 : void *argp1 = 0 ;
28341 : int res1 = 0 ;
28342 0 : PyObject * obj0 = 0 ;
28343 : shapeObj *result = 0 ;
28344 :
28345 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_nextShape",&obj0)) SWIG_fail;
28346 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28347 0 : if (!SWIG_IsOK(res1)) {
28348 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_nextShape" "', argument " "1"" of type '" "struct layerObj *""'");
28349 : }
28350 0 : arg1 = (struct layerObj *)(argp1);
28351 : {
28352 0 : result = (shapeObj *)layerObj_nextShape(arg1); {
28353 0 : errorObj *ms_error = msGetErrorObj();
28354 :
28355 0 : switch(ms_error->code) {
28356 : case MS_NOERR:
28357 : break;
28358 0 : case MS_NOTFOUND:
28359 0 : msResetErrorList();
28360 0 : break;
28361 : case -1:
28362 : break;
28363 0 : case MS_IOERR:
28364 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28365 0 : _raise_ms_exception();
28366 0 : msResetErrorList();
28367 0 : return NULL;
28368 : }
28369 : default:
28370 0 : _raise_ms_exception();
28371 0 : msResetErrorList();
28372 0 : return NULL;
28373 : }
28374 :
28375 : }
28376 : }
28377 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
28378 0 : return resultobj;
28379 0 : fail:
28380 : return NULL;
28381 : }
28382 :
28383 :
28384 1 : SWIGINTERN PyObject *_wrap_layerObj_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28385 : PyObject *resultobj = 0;
28386 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28387 1 : void *argp1 = 0 ;
28388 : int res1 = 0 ;
28389 1 : PyObject * obj0 = 0 ;
28390 :
28391 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_close",&obj0)) SWIG_fail;
28392 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28393 1 : if (!SWIG_IsOK(res1)) {
28394 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_close" "', argument " "1"" of type '" "struct layerObj *""'");
28395 : }
28396 1 : arg1 = (struct layerObj *)(argp1);
28397 : {
28398 : layerObj_close(arg1); {
28399 1 : errorObj *ms_error = msGetErrorObj();
28400 :
28401 1 : switch(ms_error->code) {
28402 : case MS_NOERR:
28403 : break;
28404 0 : case MS_NOTFOUND:
28405 0 : msResetErrorList();
28406 0 : break;
28407 : case -1:
28408 : break;
28409 0 : case MS_IOERR:
28410 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28411 0 : _raise_ms_exception();
28412 0 : msResetErrorList();
28413 0 : return NULL;
28414 : }
28415 : default:
28416 0 : _raise_ms_exception();
28417 0 : msResetErrorList();
28418 0 : return NULL;
28419 : }
28420 :
28421 : }
28422 : }
28423 : resultobj = SWIG_Py_Void();
28424 1 : return resultobj;
28425 0 : fail:
28426 : return NULL;
28427 : }
28428 :
28429 :
28430 1 : SWIGINTERN PyObject *_wrap_layerObj_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28431 : PyObject *resultobj = 0;
28432 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28433 : resultObj *arg2 = (resultObj *) 0 ;
28434 1 : void *argp1 = 0 ;
28435 : int res1 = 0 ;
28436 1 : void *argp2 = 0 ;
28437 : int res2 = 0 ;
28438 1 : PyObject * obj0 = 0 ;
28439 1 : PyObject * obj1 = 0 ;
28440 : shapeObj *result = 0 ;
28441 :
28442 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getShape",&obj0,&obj1)) SWIG_fail;
28443 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28444 1 : if (!SWIG_IsOK(res1)) {
28445 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getShape" "', argument " "1"" of type '" "struct layerObj *""'");
28446 : }
28447 1 : arg1 = (struct layerObj *)(argp1);
28448 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_resultObj, 0 | 0 );
28449 1 : if (!SWIG_IsOK(res2)) {
28450 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getShape" "', argument " "2"" of type '" "resultObj *""'");
28451 : }
28452 1 : arg2 = (resultObj *)(argp2);
28453 : {
28454 1 : result = (shapeObj *)layerObj_getShape(arg1,arg2); {
28455 1 : errorObj *ms_error = msGetErrorObj();
28456 :
28457 1 : switch(ms_error->code) {
28458 : case MS_NOERR:
28459 : break;
28460 0 : case MS_NOTFOUND:
28461 0 : msResetErrorList();
28462 0 : break;
28463 : case -1:
28464 : break;
28465 0 : case MS_IOERR:
28466 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28467 0 : _raise_ms_exception();
28468 0 : msResetErrorList();
28469 0 : return NULL;
28470 : }
28471 : default:
28472 0 : _raise_ms_exception();
28473 0 : msResetErrorList();
28474 0 : return NULL;
28475 : }
28476 :
28477 : }
28478 : }
28479 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
28480 1 : return resultobj;
28481 0 : fail:
28482 : return NULL;
28483 : }
28484 :
28485 :
28486 1 : SWIGINTERN PyObject *_wrap_layerObj_getNumResults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28487 : PyObject *resultobj = 0;
28488 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28489 1 : void *argp1 = 0 ;
28490 : int res1 = 0 ;
28491 1 : PyObject * obj0 = 0 ;
28492 : int result;
28493 :
28494 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getNumResults",&obj0)) SWIG_fail;
28495 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28496 1 : if (!SWIG_IsOK(res1)) {
28497 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNumResults" "', argument " "1"" of type '" "struct layerObj *""'");
28498 : }
28499 1 : arg1 = (struct layerObj *)(argp1);
28500 : {
28501 1 : result = (int)layerObj_getNumResults(arg1); {
28502 1 : errorObj *ms_error = msGetErrorObj();
28503 :
28504 1 : switch(ms_error->code) {
28505 : case MS_NOERR:
28506 : break;
28507 0 : case MS_NOTFOUND:
28508 0 : msResetErrorList();
28509 0 : break;
28510 : case -1:
28511 : break;
28512 0 : case MS_IOERR:
28513 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28514 0 : _raise_ms_exception();
28515 0 : msResetErrorList();
28516 0 : return NULL;
28517 : }
28518 : default:
28519 0 : _raise_ms_exception();
28520 0 : msResetErrorList();
28521 0 : return NULL;
28522 : }
28523 :
28524 : }
28525 : }
28526 : resultobj = SWIG_From_int((int)(result));
28527 1 : return resultobj;
28528 0 : fail:
28529 : return NULL;
28530 : }
28531 :
28532 :
28533 0 : SWIGINTERN PyObject *_wrap_layerObj_getResultsBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28534 : PyObject *resultobj = 0;
28535 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28536 0 : void *argp1 = 0 ;
28537 : int res1 = 0 ;
28538 0 : PyObject * obj0 = 0 ;
28539 : rectObj *result = 0 ;
28540 :
28541 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getResultsBounds",&obj0)) SWIG_fail;
28542 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28543 0 : if (!SWIG_IsOK(res1)) {
28544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResultsBounds" "', argument " "1"" of type '" "struct layerObj *""'");
28545 : }
28546 0 : arg1 = (struct layerObj *)(argp1);
28547 : {
28548 0 : result = (rectObj *)layerObj_getResultsBounds(arg1); {
28549 0 : errorObj *ms_error = msGetErrorObj();
28550 :
28551 0 : switch(ms_error->code) {
28552 : case MS_NOERR:
28553 : break;
28554 0 : case MS_NOTFOUND:
28555 0 : msResetErrorList();
28556 0 : break;
28557 : case -1:
28558 : break;
28559 0 : case MS_IOERR:
28560 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28561 0 : _raise_ms_exception();
28562 0 : msResetErrorList();
28563 0 : return NULL;
28564 : }
28565 : default:
28566 0 : _raise_ms_exception();
28567 0 : msResetErrorList();
28568 0 : return NULL;
28569 : }
28570 :
28571 : }
28572 : }
28573 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_OWN | 0 );
28574 0 : return resultobj;
28575 0 : fail:
28576 : return NULL;
28577 : }
28578 :
28579 :
28580 1 : SWIGINTERN PyObject *_wrap_layerObj_getResult(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28581 : PyObject *resultobj = 0;
28582 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28583 : int arg2 ;
28584 1 : void *argp1 = 0 ;
28585 : int res1 = 0 ;
28586 : int val2 ;
28587 : int ecode2 = 0 ;
28588 1 : PyObject * obj0 = 0 ;
28589 1 : PyObject * obj1 = 0 ;
28590 : resultObj *result = 0 ;
28591 :
28592 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getResult",&obj0,&obj1)) SWIG_fail;
28593 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28594 1 : if (!SWIG_IsOK(res1)) {
28595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResult" "', argument " "1"" of type '" "struct layerObj *""'");
28596 : }
28597 1 : arg1 = (struct layerObj *)(argp1);
28598 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28599 1 : if (!SWIG_IsOK(ecode2)) {
28600 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getResult" "', argument " "2"" of type '" "int""'");
28601 : }
28602 : arg2 = (int)(val2);
28603 : {
28604 1 : result = (resultObj *)layerObj_getResult(arg1,arg2); {
28605 1 : errorObj *ms_error = msGetErrorObj();
28606 :
28607 1 : switch(ms_error->code) {
28608 : case MS_NOERR:
28609 : break;
28610 0 : case MS_NOTFOUND:
28611 0 : msResetErrorList();
28612 0 : break;
28613 : case -1:
28614 : break;
28615 0 : case MS_IOERR:
28616 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28617 0 : _raise_ms_exception();
28618 0 : msResetErrorList();
28619 0 : return NULL;
28620 : }
28621 : default:
28622 0 : _raise_ms_exception();
28623 0 : msResetErrorList();
28624 0 : return NULL;
28625 : }
28626 :
28627 : }
28628 : }
28629 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultObj, 0 | 0 );
28630 1 : return resultobj;
28631 0 : fail:
28632 : return NULL;
28633 : }
28634 :
28635 :
28636 1 : SWIGINTERN PyObject *_wrap_layerObj_getClass(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28637 : PyObject *resultobj = 0;
28638 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28639 : int arg2 ;
28640 1 : void *argp1 = 0 ;
28641 : int res1 = 0 ;
28642 : int val2 ;
28643 : int ecode2 = 0 ;
28644 1 : PyObject * obj0 = 0 ;
28645 1 : PyObject * obj1 = 0 ;
28646 : classObj *result = 0 ;
28647 :
28648 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getClass",&obj0,&obj1)) SWIG_fail;
28649 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28650 1 : if (!SWIG_IsOK(res1)) {
28651 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getClass" "', argument " "1"" of type '" "struct layerObj *""'");
28652 : }
28653 1 : arg1 = (struct layerObj *)(argp1);
28654 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28655 1 : if (!SWIG_IsOK(ecode2)) {
28656 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getClass" "', argument " "2"" of type '" "int""'");
28657 : }
28658 : arg2 = (int)(val2);
28659 : {
28660 : result = (classObj *)layerObj_getClass(arg1,arg2); {
28661 1 : errorObj *ms_error = msGetErrorObj();
28662 :
28663 1 : switch(ms_error->code) {
28664 : case MS_NOERR:
28665 : break;
28666 0 : case MS_NOTFOUND:
28667 0 : msResetErrorList();
28668 0 : break;
28669 : case -1:
28670 : break;
28671 0 : case MS_IOERR:
28672 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28673 0 : _raise_ms_exception();
28674 0 : msResetErrorList();
28675 0 : return NULL;
28676 : }
28677 : default:
28678 0 : _raise_ms_exception();
28679 0 : msResetErrorList();
28680 0 : return NULL;
28681 : }
28682 :
28683 : }
28684 : }
28685 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_classObj, SWIG_POINTER_OWN | 0 );
28686 1 : return resultobj;
28687 0 : fail:
28688 : return NULL;
28689 : }
28690 :
28691 :
28692 1 : SWIGINTERN PyObject *_wrap_layerObj_getItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28693 : PyObject *resultobj = 0;
28694 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28695 : int arg2 ;
28696 1 : void *argp1 = 0 ;
28697 : int res1 = 0 ;
28698 : int val2 ;
28699 : int ecode2 = 0 ;
28700 1 : PyObject * obj0 = 0 ;
28701 1 : PyObject * obj1 = 0 ;
28702 : char *result = 0 ;
28703 :
28704 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getItem",&obj0,&obj1)) SWIG_fail;
28705 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28706 1 : if (!SWIG_IsOK(res1)) {
28707 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getItem" "', argument " "1"" of type '" "struct layerObj *""'");
28708 : }
28709 1 : arg1 = (struct layerObj *)(argp1);
28710 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
28711 1 : if (!SWIG_IsOK(ecode2)) {
28712 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getItem" "', argument " "2"" of type '" "int""'");
28713 : }
28714 : arg2 = (int)(val2);
28715 : {
28716 : result = (char *)layerObj_getItem(arg1,arg2); {
28717 1 : errorObj *ms_error = msGetErrorObj();
28718 :
28719 1 : switch(ms_error->code) {
28720 : case MS_NOERR:
28721 : break;
28722 0 : case MS_NOTFOUND:
28723 0 : msResetErrorList();
28724 0 : break;
28725 : case -1:
28726 : break;
28727 0 : case MS_IOERR:
28728 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28729 0 : _raise_ms_exception();
28730 0 : msResetErrorList();
28731 0 : return NULL;
28732 : }
28733 : default:
28734 0 : _raise_ms_exception();
28735 0 : msResetErrorList();
28736 0 : return NULL;
28737 : }
28738 :
28739 : }
28740 : }
28741 1 : resultobj = SWIG_FromCharPtr((const char *)result);
28742 1 : return resultobj;
28743 0 : fail:
28744 : return NULL;
28745 : }
28746 :
28747 :
28748 0 : SWIGINTERN PyObject *_wrap_layerObj_setItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28749 : PyObject *resultobj = 0;
28750 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28751 : char **arg2 = (char **) 0 ;
28752 : int arg3 ;
28753 0 : void *argp1 = 0 ;
28754 : int res1 = 0 ;
28755 0 : void *argp2 = 0 ;
28756 : int res2 = 0 ;
28757 : int val3 ;
28758 : int ecode3 = 0 ;
28759 0 : PyObject * obj0 = 0 ;
28760 0 : PyObject * obj1 = 0 ;
28761 0 : PyObject * obj2 = 0 ;
28762 : int result;
28763 :
28764 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setItems",&obj0,&obj1,&obj2)) SWIG_fail;
28765 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28766 0 : if (!SWIG_IsOK(res1)) {
28767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setItems" "', argument " "1"" of type '" "struct layerObj *""'");
28768 : }
28769 0 : arg1 = (struct layerObj *)(argp1);
28770 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 | 0 );
28771 0 : if (!SWIG_IsOK(res2)) {
28772 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setItems" "', argument " "2"" of type '" "char **""'");
28773 : }
28774 0 : arg2 = (char **)(argp2);
28775 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
28776 0 : if (!SWIG_IsOK(ecode3)) {
28777 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_setItems" "', argument " "3"" of type '" "int""'");
28778 : }
28779 : arg3 = (int)(val3);
28780 : {
28781 : result = (int)layerObj_setItems(arg1,arg2,arg3); {
28782 0 : errorObj *ms_error = msGetErrorObj();
28783 :
28784 0 : switch(ms_error->code) {
28785 : case MS_NOERR:
28786 : break;
28787 0 : case MS_NOTFOUND:
28788 0 : msResetErrorList();
28789 0 : break;
28790 : case -1:
28791 : break;
28792 0 : case MS_IOERR:
28793 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28794 0 : _raise_ms_exception();
28795 0 : msResetErrorList();
28796 0 : return NULL;
28797 : }
28798 : default:
28799 0 : _raise_ms_exception();
28800 0 : msResetErrorList();
28801 0 : return NULL;
28802 : }
28803 :
28804 : }
28805 : }
28806 : resultobj = SWIG_From_int((int)(result));
28807 0 : return resultobj;
28808 0 : fail:
28809 : return NULL;
28810 : }
28811 :
28812 :
28813 0 : SWIGINTERN PyObject *_wrap_layerObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28814 : PyObject *resultobj = 0;
28815 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28816 : mapObj *arg2 = (mapObj *) 0 ;
28817 : imageObj *arg3 = (imageObj *) 0 ;
28818 0 : void *argp1 = 0 ;
28819 : int res1 = 0 ;
28820 0 : void *argp2 = 0 ;
28821 : int res2 = 0 ;
28822 0 : void *argp3 = 0 ;
28823 : int res3 = 0 ;
28824 0 : PyObject * obj0 = 0 ;
28825 0 : PyObject * obj1 = 0 ;
28826 0 : PyObject * obj2 = 0 ;
28827 : int result;
28828 :
28829 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_draw",&obj0,&obj1,&obj2)) SWIG_fail;
28830 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28831 0 : if (!SWIG_IsOK(res1)) {
28832 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_draw" "', argument " "1"" of type '" "struct layerObj *""'");
28833 : }
28834 0 : arg1 = (struct layerObj *)(argp1);
28835 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
28836 0 : if (!SWIG_IsOK(res2)) {
28837 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_draw" "', argument " "2"" of type '" "mapObj *""'");
28838 : }
28839 0 : arg2 = (mapObj *)(argp2);
28840 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_imageObj, 0 | 0 );
28841 0 : if (!SWIG_IsOK(res3)) {
28842 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_draw" "', argument " "3"" of type '" "imageObj *""'");
28843 : }
28844 0 : arg3 = (imageObj *)(argp3);
28845 : {
28846 : result = (int)layerObj_draw(arg1,arg2,arg3); {
28847 0 : errorObj *ms_error = msGetErrorObj();
28848 :
28849 0 : switch(ms_error->code) {
28850 : case MS_NOERR:
28851 : break;
28852 0 : case MS_NOTFOUND:
28853 0 : msResetErrorList();
28854 0 : break;
28855 : case -1:
28856 : break;
28857 0 : case MS_IOERR:
28858 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28859 0 : _raise_ms_exception();
28860 0 : msResetErrorList();
28861 0 : return NULL;
28862 : }
28863 : default:
28864 0 : _raise_ms_exception();
28865 0 : msResetErrorList();
28866 0 : return NULL;
28867 : }
28868 :
28869 : }
28870 : }
28871 : resultobj = SWIG_From_int((int)(result));
28872 0 : return resultobj;
28873 0 : fail:
28874 : return NULL;
28875 : }
28876 :
28877 :
28878 0 : SWIGINTERN PyObject *_wrap_layerObj_drawQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28879 : PyObject *resultobj = 0;
28880 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28881 : mapObj *arg2 = (mapObj *) 0 ;
28882 : imageObj *arg3 = (imageObj *) 0 ;
28883 0 : void *argp1 = 0 ;
28884 : int res1 = 0 ;
28885 0 : void *argp2 = 0 ;
28886 : int res2 = 0 ;
28887 0 : void *argp3 = 0 ;
28888 : int res3 = 0 ;
28889 0 : PyObject * obj0 = 0 ;
28890 0 : PyObject * obj1 = 0 ;
28891 0 : PyObject * obj2 = 0 ;
28892 : int result;
28893 :
28894 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_drawQuery",&obj0,&obj1,&obj2)) SWIG_fail;
28895 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28896 0 : if (!SWIG_IsOK(res1)) {
28897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_drawQuery" "', argument " "1"" of type '" "struct layerObj *""'");
28898 : }
28899 0 : arg1 = (struct layerObj *)(argp1);
28900 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
28901 0 : if (!SWIG_IsOK(res2)) {
28902 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_drawQuery" "', argument " "2"" of type '" "mapObj *""'");
28903 : }
28904 0 : arg2 = (mapObj *)(argp2);
28905 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_imageObj, 0 | 0 );
28906 0 : if (!SWIG_IsOK(res3)) {
28907 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_drawQuery" "', argument " "3"" of type '" "imageObj *""'");
28908 : }
28909 0 : arg3 = (imageObj *)(argp3);
28910 : {
28911 : result = (int)layerObj_drawQuery(arg1,arg2,arg3); {
28912 0 : errorObj *ms_error = msGetErrorObj();
28913 :
28914 0 : switch(ms_error->code) {
28915 : case MS_NOERR:
28916 : break;
28917 0 : case MS_NOTFOUND:
28918 0 : msResetErrorList();
28919 0 : break;
28920 : case -1:
28921 : break;
28922 0 : case MS_IOERR:
28923 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28924 0 : _raise_ms_exception();
28925 0 : msResetErrorList();
28926 0 : return NULL;
28927 : }
28928 : default:
28929 0 : _raise_ms_exception();
28930 0 : msResetErrorList();
28931 0 : return NULL;
28932 : }
28933 :
28934 : }
28935 : }
28936 : resultobj = SWIG_From_int((int)(result));
28937 0 : return resultobj;
28938 0 : fail:
28939 : return NULL;
28940 : }
28941 :
28942 :
28943 0 : SWIGINTERN PyObject *_wrap_layerObj_queryByFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28944 : PyObject *resultobj = 0;
28945 : struct layerObj *arg1 = (struct layerObj *) 0 ;
28946 : mapObj *arg2 = (mapObj *) 0 ;
28947 : char *arg3 = (char *) 0 ;
28948 0 : void *argp1 = 0 ;
28949 : int res1 = 0 ;
28950 0 : void *argp2 = 0 ;
28951 : int res2 = 0 ;
28952 : int res3 ;
28953 0 : char *buf3 = 0 ;
28954 0 : int alloc3 = 0 ;
28955 0 : PyObject * obj0 = 0 ;
28956 0 : PyObject * obj1 = 0 ;
28957 0 : PyObject * obj2 = 0 ;
28958 : int result;
28959 :
28960 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByFilter",&obj0,&obj1,&obj2)) SWIG_fail;
28961 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
28962 0 : if (!SWIG_IsOK(res1)) {
28963 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByFilter" "', argument " "1"" of type '" "struct layerObj *""'");
28964 : }
28965 0 : arg1 = (struct layerObj *)(argp1);
28966 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
28967 0 : if (!SWIG_IsOK(res2)) {
28968 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByFilter" "', argument " "2"" of type '" "mapObj *""'");
28969 : }
28970 0 : arg2 = (mapObj *)(argp2);
28971 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
28972 0 : if (!SWIG_IsOK(res3)) {
28973 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByFilter" "', argument " "3"" of type '" "char *""'");
28974 : }
28975 0 : arg3 = (char *)(buf3);
28976 : {
28977 0 : result = (int)layerObj_queryByFilter(arg1,arg2,arg3); {
28978 0 : errorObj *ms_error = msGetErrorObj();
28979 :
28980 0 : switch(ms_error->code) {
28981 : case MS_NOERR:
28982 : break;
28983 0 : case MS_NOTFOUND:
28984 0 : msResetErrorList();
28985 0 : break;
28986 : case -1:
28987 : break;
28988 0 : case MS_IOERR:
28989 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
28990 0 : _raise_ms_exception();
28991 0 : msResetErrorList();
28992 0 : return NULL;
28993 : }
28994 : default:
28995 0 : _raise_ms_exception();
28996 0 : msResetErrorList();
28997 0 : return NULL;
28998 : }
28999 :
29000 : }
29001 : }
29002 : resultobj = SWIG_From_int((int)(result));
29003 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
29004 : return resultobj;
29005 0 : fail:
29006 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
29007 : return NULL;
29008 : }
29009 :
29010 :
29011 1 : SWIGINTERN PyObject *_wrap_layerObj_queryByAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29012 : PyObject *resultobj = 0;
29013 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29014 : mapObj *arg2 = (mapObj *) 0 ;
29015 : char *arg3 = (char *) 0 ;
29016 : char *arg4 = (char *) 0 ;
29017 : int arg5 ;
29018 1 : void *argp1 = 0 ;
29019 : int res1 = 0 ;
29020 1 : void *argp2 = 0 ;
29021 : int res2 = 0 ;
29022 : int res3 ;
29023 1 : char *buf3 = 0 ;
29024 1 : int alloc3 = 0 ;
29025 : int res4 ;
29026 1 : char *buf4 = 0 ;
29027 1 : int alloc4 = 0 ;
29028 : int val5 ;
29029 : int ecode5 = 0 ;
29030 1 : PyObject * obj0 = 0 ;
29031 1 : PyObject * obj1 = 0 ;
29032 1 : PyObject * obj2 = 0 ;
29033 1 : PyObject * obj3 = 0 ;
29034 1 : PyObject * obj4 = 0 ;
29035 : int result;
29036 :
29037 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:layerObj_queryByAttributes",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29038 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29039 1 : if (!SWIG_IsOK(res1)) {
29040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByAttributes" "', argument " "1"" of type '" "struct layerObj *""'");
29041 : }
29042 1 : arg1 = (struct layerObj *)(argp1);
29043 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29044 1 : if (!SWIG_IsOK(res2)) {
29045 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByAttributes" "', argument " "2"" of type '" "mapObj *""'");
29046 : }
29047 1 : arg2 = (mapObj *)(argp2);
29048 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
29049 1 : if (!SWIG_IsOK(res3)) {
29050 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByAttributes" "', argument " "3"" of type '" "char *""'");
29051 : }
29052 1 : arg3 = (char *)(buf3);
29053 1 : res4 = SWIG_AsCharPtrAndSize(obj3, &buf4, NULL, &alloc4);
29054 1 : if (!SWIG_IsOK(res4)) {
29055 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "layerObj_queryByAttributes" "', argument " "4"" of type '" "char *""'");
29056 : }
29057 1 : arg4 = (char *)(buf4);
29058 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
29059 1 : if (!SWIG_IsOK(ecode5)) {
29060 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByAttributes" "', argument " "5"" of type '" "int""'");
29061 : }
29062 : arg5 = (int)(val5);
29063 : {
29064 1 : result = (int)layerObj_queryByAttributes(arg1,arg2,arg3,arg4,arg5); {
29065 1 : errorObj *ms_error = msGetErrorObj();
29066 :
29067 1 : switch(ms_error->code) {
29068 : case MS_NOERR:
29069 : break;
29070 1 : case MS_NOTFOUND:
29071 1 : msResetErrorList();
29072 1 : break;
29073 : case -1:
29074 : break;
29075 0 : case MS_IOERR:
29076 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29077 0 : _raise_ms_exception();
29078 0 : msResetErrorList();
29079 0 : return NULL;
29080 : }
29081 : default:
29082 0 : _raise_ms_exception();
29083 0 : msResetErrorList();
29084 0 : return NULL;
29085 : }
29086 :
29087 : }
29088 : }
29089 : resultobj = SWIG_From_int((int)(result));
29090 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
29091 1 : if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
29092 : return resultobj;
29093 0 : fail:
29094 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
29095 0 : if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
29096 : return NULL;
29097 : }
29098 :
29099 :
29100 1 : SWIGINTERN PyObject *_wrap_layerObj_queryByPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29101 : PyObject *resultobj = 0;
29102 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29103 : mapObj *arg2 = (mapObj *) 0 ;
29104 : pointObj *arg3 = (pointObj *) 0 ;
29105 : int arg4 ;
29106 : double arg5 ;
29107 1 : void *argp1 = 0 ;
29108 : int res1 = 0 ;
29109 1 : void *argp2 = 0 ;
29110 : int res2 = 0 ;
29111 1 : void *argp3 = 0 ;
29112 : int res3 = 0 ;
29113 : int val4 ;
29114 : int ecode4 = 0 ;
29115 : double val5 ;
29116 : int ecode5 = 0 ;
29117 1 : PyObject * obj0 = 0 ;
29118 1 : PyObject * obj1 = 0 ;
29119 1 : PyObject * obj2 = 0 ;
29120 1 : PyObject * obj3 = 0 ;
29121 1 : PyObject * obj4 = 0 ;
29122 : int result;
29123 :
29124 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:layerObj_queryByPoint",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29125 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29126 1 : if (!SWIG_IsOK(res1)) {
29127 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByPoint" "', argument " "1"" of type '" "struct layerObj *""'");
29128 : }
29129 1 : arg1 = (struct layerObj *)(argp1);
29130 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29131 1 : if (!SWIG_IsOK(res2)) {
29132 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByPoint" "', argument " "2"" of type '" "mapObj *""'");
29133 : }
29134 1 : arg2 = (mapObj *)(argp2);
29135 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
29136 1 : if (!SWIG_IsOK(res3)) {
29137 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByPoint" "', argument " "3"" of type '" "pointObj *""'");
29138 : }
29139 1 : arg3 = (pointObj *)(argp3);
29140 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
29141 1 : if (!SWIG_IsOK(ecode4)) {
29142 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_queryByPoint" "', argument " "4"" of type '" "int""'");
29143 : }
29144 : arg4 = (int)(val4);
29145 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
29146 1 : if (!SWIG_IsOK(ecode5)) {
29147 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByPoint" "', argument " "5"" of type '" "double""'");
29148 : }
29149 1 : arg5 = (double)(val5);
29150 : {
29151 : result = (int)layerObj_queryByPoint(arg1,arg2,arg3,arg4,arg5); {
29152 1 : errorObj *ms_error = msGetErrorObj();
29153 :
29154 1 : switch(ms_error->code) {
29155 : case MS_NOERR:
29156 : break;
29157 1 : case MS_NOTFOUND:
29158 1 : msResetErrorList();
29159 1 : break;
29160 : case -1:
29161 : break;
29162 0 : case MS_IOERR:
29163 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29164 0 : _raise_ms_exception();
29165 0 : msResetErrorList();
29166 0 : return NULL;
29167 : }
29168 : default:
29169 0 : _raise_ms_exception();
29170 0 : msResetErrorList();
29171 0 : return NULL;
29172 : }
29173 :
29174 : }
29175 : }
29176 : resultobj = SWIG_From_int((int)(result));
29177 1 : return resultobj;
29178 0 : fail:
29179 : return NULL;
29180 : }
29181 :
29182 :
29183 1 : SWIGINTERN PyObject *_wrap_layerObj_queryByRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29184 : PyObject *resultobj = 0;
29185 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29186 : mapObj *arg2 = (mapObj *) 0 ;
29187 : rectObj arg3 ;
29188 1 : void *argp1 = 0 ;
29189 : int res1 = 0 ;
29190 1 : void *argp2 = 0 ;
29191 : int res2 = 0 ;
29192 : void *argp3 ;
29193 : int res3 = 0 ;
29194 1 : PyObject * obj0 = 0 ;
29195 1 : PyObject * obj1 = 0 ;
29196 1 : PyObject * obj2 = 0 ;
29197 : int result;
29198 :
29199 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByRect",&obj0,&obj1,&obj2)) SWIG_fail;
29200 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29201 1 : if (!SWIG_IsOK(res1)) {
29202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByRect" "', argument " "1"" of type '" "struct layerObj *""'");
29203 : }
29204 1 : arg1 = (struct layerObj *)(argp1);
29205 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29206 1 : if (!SWIG_IsOK(res2)) {
29207 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByRect" "', argument " "2"" of type '" "mapObj *""'");
29208 : }
29209 1 : arg2 = (mapObj *)(argp2);
29210 : {
29211 1 : res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_rectObj, 0 );
29212 1 : if (!SWIG_IsOK(res3)) {
29213 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByRect" "', argument " "3"" of type '" "rectObj""'");
29214 : }
29215 1 : if (!argp3) {
29216 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "layerObj_queryByRect" "', argument " "3"" of type '" "rectObj""'");
29217 : } else {
29218 1 : arg3 = *((rectObj *)(argp3));
29219 : }
29220 : }
29221 : {
29222 : result = (int)layerObj_queryByRect(arg1,arg2,arg3); {
29223 1 : errorObj *ms_error = msGetErrorObj();
29224 :
29225 1 : switch(ms_error->code) {
29226 : case MS_NOERR:
29227 : break;
29228 1 : case MS_NOTFOUND:
29229 1 : msResetErrorList();
29230 1 : break;
29231 : case -1:
29232 : break;
29233 0 : case MS_IOERR:
29234 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29235 0 : _raise_ms_exception();
29236 0 : msResetErrorList();
29237 0 : return NULL;
29238 : }
29239 : default:
29240 0 : _raise_ms_exception();
29241 0 : msResetErrorList();
29242 0 : return NULL;
29243 : }
29244 :
29245 : }
29246 : }
29247 : resultobj = SWIG_From_int((int)(result));
29248 1 : return resultobj;
29249 0 : fail:
29250 : return NULL;
29251 : }
29252 :
29253 :
29254 0 : SWIGINTERN PyObject *_wrap_layerObj_queryByFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29255 : PyObject *resultobj = 0;
29256 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29257 : mapObj *arg2 = (mapObj *) 0 ;
29258 : int arg3 ;
29259 0 : void *argp1 = 0 ;
29260 : int res1 = 0 ;
29261 0 : void *argp2 = 0 ;
29262 : int res2 = 0 ;
29263 : int val3 ;
29264 : int ecode3 = 0 ;
29265 0 : PyObject * obj0 = 0 ;
29266 0 : PyObject * obj1 = 0 ;
29267 0 : PyObject * obj2 = 0 ;
29268 : int result;
29269 :
29270 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByFeatures",&obj0,&obj1,&obj2)) SWIG_fail;
29271 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29272 0 : if (!SWIG_IsOK(res1)) {
29273 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByFeatures" "', argument " "1"" of type '" "struct layerObj *""'");
29274 : }
29275 0 : arg1 = (struct layerObj *)(argp1);
29276 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29277 0 : if (!SWIG_IsOK(res2)) {
29278 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByFeatures" "', argument " "2"" of type '" "mapObj *""'");
29279 : }
29280 0 : arg2 = (mapObj *)(argp2);
29281 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
29282 0 : if (!SWIG_IsOK(ecode3)) {
29283 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_queryByFeatures" "', argument " "3"" of type '" "int""'");
29284 : }
29285 : arg3 = (int)(val3);
29286 : {
29287 0 : result = (int)layerObj_queryByFeatures(arg1,arg2,arg3); {
29288 0 : errorObj *ms_error = msGetErrorObj();
29289 :
29290 0 : switch(ms_error->code) {
29291 : case MS_NOERR:
29292 : break;
29293 0 : case MS_NOTFOUND:
29294 0 : msResetErrorList();
29295 0 : break;
29296 : case -1:
29297 : break;
29298 0 : case MS_IOERR:
29299 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29300 0 : _raise_ms_exception();
29301 0 : msResetErrorList();
29302 0 : return NULL;
29303 : }
29304 : default:
29305 0 : _raise_ms_exception();
29306 0 : msResetErrorList();
29307 0 : return NULL;
29308 : }
29309 :
29310 : }
29311 : }
29312 : resultobj = SWIG_From_int((int)(result));
29313 0 : return resultobj;
29314 0 : fail:
29315 : return NULL;
29316 : }
29317 :
29318 :
29319 1 : SWIGINTERN PyObject *_wrap_layerObj_queryByShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29320 : PyObject *resultobj = 0;
29321 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29322 : mapObj *arg2 = (mapObj *) 0 ;
29323 : shapeObj *arg3 = (shapeObj *) 0 ;
29324 1 : void *argp1 = 0 ;
29325 : int res1 = 0 ;
29326 1 : void *argp2 = 0 ;
29327 : int res2 = 0 ;
29328 1 : void *argp3 = 0 ;
29329 : int res3 = 0 ;
29330 1 : PyObject * obj0 = 0 ;
29331 1 : PyObject * obj1 = 0 ;
29332 1 : PyObject * obj2 = 0 ;
29333 : int result;
29334 :
29335 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_queryByShape",&obj0,&obj1,&obj2)) SWIG_fail;
29336 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29337 1 : if (!SWIG_IsOK(res1)) {
29338 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByShape" "', argument " "1"" of type '" "struct layerObj *""'");
29339 : }
29340 1 : arg1 = (struct layerObj *)(argp1);
29341 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29342 1 : if (!SWIG_IsOK(res2)) {
29343 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByShape" "', argument " "2"" of type '" "mapObj *""'");
29344 : }
29345 1 : arg2 = (mapObj *)(argp2);
29346 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 | 0 );
29347 1 : if (!SWIG_IsOK(res3)) {
29348 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_queryByShape" "', argument " "3"" of type '" "shapeObj *""'");
29349 : }
29350 1 : arg3 = (shapeObj *)(argp3);
29351 : {
29352 1 : result = (int)layerObj_queryByShape(arg1,arg2,arg3); {
29353 1 : errorObj *ms_error = msGetErrorObj();
29354 :
29355 1 : switch(ms_error->code) {
29356 : case MS_NOERR:
29357 : break;
29358 1 : case MS_NOTFOUND:
29359 1 : msResetErrorList();
29360 1 : break;
29361 : case -1:
29362 : break;
29363 0 : case MS_IOERR:
29364 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29365 0 : _raise_ms_exception();
29366 0 : msResetErrorList();
29367 0 : return NULL;
29368 : }
29369 : default:
29370 0 : _raise_ms_exception();
29371 0 : msResetErrorList();
29372 0 : return NULL;
29373 : }
29374 :
29375 : }
29376 : }
29377 : resultobj = SWIG_From_int((int)(result));
29378 1 : return resultobj;
29379 0 : fail:
29380 : return NULL;
29381 : }
29382 :
29383 :
29384 1 : SWIGINTERN PyObject *_wrap_layerObj_queryByIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29385 : PyObject *resultobj = 0;
29386 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29387 : mapObj *arg2 = (mapObj *) 0 ;
29388 : int arg3 ;
29389 : int arg4 ;
29390 : int arg5 = (int) 0 ;
29391 1 : void *argp1 = 0 ;
29392 : int res1 = 0 ;
29393 1 : void *argp2 = 0 ;
29394 : int res2 = 0 ;
29395 : int val3 ;
29396 : int ecode3 = 0 ;
29397 : int val4 ;
29398 : int ecode4 = 0 ;
29399 : int val5 ;
29400 : int ecode5 = 0 ;
29401 1 : PyObject * obj0 = 0 ;
29402 1 : PyObject * obj1 = 0 ;
29403 1 : PyObject * obj2 = 0 ;
29404 1 : PyObject * obj3 = 0 ;
29405 1 : PyObject * obj4 = 0 ;
29406 : int result;
29407 :
29408 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO|O:layerObj_queryByIndex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29409 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29410 1 : if (!SWIG_IsOK(res1)) {
29411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_queryByIndex" "', argument " "1"" of type '" "struct layerObj *""'");
29412 : }
29413 1 : arg1 = (struct layerObj *)(argp1);
29414 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
29415 1 : if (!SWIG_IsOK(res2)) {
29416 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_queryByIndex" "', argument " "2"" of type '" "mapObj *""'");
29417 : }
29418 1 : arg2 = (mapObj *)(argp2);
29419 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
29420 1 : if (!SWIG_IsOK(ecode3)) {
29421 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_queryByIndex" "', argument " "3"" of type '" "int""'");
29422 : }
29423 : arg3 = (int)(val3);
29424 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
29425 1 : if (!SWIG_IsOK(ecode4)) {
29426 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_queryByIndex" "', argument " "4"" of type '" "int""'");
29427 : }
29428 : arg4 = (int)(val4);
29429 1 : if (obj4) {
29430 : ecode5 = SWIG_AsVal_int(obj4, &val5);
29431 1 : if (!SWIG_IsOK(ecode5)) {
29432 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_queryByIndex" "', argument " "5"" of type '" "int""'");
29433 : }
29434 : arg5 = (int)(val5);
29435 : }
29436 : {
29437 : result = (int)layerObj_queryByIndex(arg1,arg2,arg3,arg4,arg5); {
29438 1 : errorObj *ms_error = msGetErrorObj();
29439 :
29440 1 : switch(ms_error->code) {
29441 : case MS_NOERR:
29442 : break;
29443 0 : case MS_NOTFOUND:
29444 0 : msResetErrorList();
29445 0 : break;
29446 : case -1:
29447 : break;
29448 0 : case MS_IOERR:
29449 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29450 0 : _raise_ms_exception();
29451 0 : msResetErrorList();
29452 0 : return NULL;
29453 : }
29454 : default:
29455 0 : _raise_ms_exception();
29456 0 : msResetErrorList();
29457 0 : return NULL;
29458 : }
29459 :
29460 : }
29461 : }
29462 : resultobj = SWIG_From_int((int)(result));
29463 1 : return resultobj;
29464 0 : fail:
29465 : return NULL;
29466 : }
29467 :
29468 :
29469 1 : SWIGINTERN PyObject *_wrap_layerObj_getResults(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29470 : PyObject *resultobj = 0;
29471 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29472 1 : void *argp1 = 0 ;
29473 : int res1 = 0 ;
29474 1 : PyObject * obj0 = 0 ;
29475 : resultCacheObj *result = 0 ;
29476 :
29477 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getResults",&obj0)) SWIG_fail;
29478 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29479 1 : if (!SWIG_IsOK(res1)) {
29480 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getResults" "', argument " "1"" of type '" "struct layerObj *""'");
29481 : }
29482 1 : arg1 = (struct layerObj *)(argp1);
29483 : {
29484 1 : result = (resultCacheObj *)layerObj_getResults(arg1); {
29485 1 : errorObj *ms_error = msGetErrorObj();
29486 :
29487 1 : switch(ms_error->code) {
29488 : case MS_NOERR:
29489 : break;
29490 0 : case MS_NOTFOUND:
29491 0 : msResetErrorList();
29492 0 : break;
29493 : case -1:
29494 : break;
29495 0 : case MS_IOERR:
29496 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29497 0 : _raise_ms_exception();
29498 0 : msResetErrorList();
29499 0 : return NULL;
29500 : }
29501 : default:
29502 0 : _raise_ms_exception();
29503 0 : msResetErrorList();
29504 0 : return NULL;
29505 : }
29506 :
29507 : }
29508 : }
29509 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_resultCacheObj, 0 | 0 );
29510 1 : return resultobj;
29511 0 : fail:
29512 : return NULL;
29513 : }
29514 :
29515 :
29516 1 : SWIGINTERN PyObject *_wrap_layerObj_setFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29517 : PyObject *resultobj = 0;
29518 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29519 : char *arg2 = (char *) 0 ;
29520 1 : void *argp1 = 0 ;
29521 : int res1 = 0 ;
29522 : int res2 ;
29523 1 : char *buf2 = 0 ;
29524 1 : int alloc2 = 0 ;
29525 1 : PyObject * obj0 = 0 ;
29526 1 : PyObject * obj1 = 0 ;
29527 : int result;
29528 :
29529 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setFilter",&obj0,&obj1)) SWIG_fail;
29530 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29531 1 : if (!SWIG_IsOK(res1)) {
29532 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setFilter" "', argument " "1"" of type '" "struct layerObj *""'");
29533 : }
29534 1 : arg1 = (struct layerObj *)(argp1);
29535 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29536 1 : if (!SWIG_IsOK(res2)) {
29537 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setFilter" "', argument " "2"" of type '" "char *""'");
29538 : }
29539 1 : arg2 = (char *)(buf2);
29540 : {
29541 1 : result = (int)layerObj_setFilter(arg1,arg2); {
29542 1 : errorObj *ms_error = msGetErrorObj();
29543 :
29544 1 : switch(ms_error->code) {
29545 : case MS_NOERR:
29546 : break;
29547 0 : case MS_NOTFOUND:
29548 0 : msResetErrorList();
29549 0 : break;
29550 : case -1:
29551 : break;
29552 0 : case MS_IOERR:
29553 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29554 0 : _raise_ms_exception();
29555 0 : msResetErrorList();
29556 0 : return NULL;
29557 : }
29558 : default:
29559 0 : _raise_ms_exception();
29560 0 : msResetErrorList();
29561 0 : return NULL;
29562 : }
29563 :
29564 : }
29565 : }
29566 : resultobj = SWIG_From_int((int)(result));
29567 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29568 : return resultobj;
29569 0 : fail:
29570 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29571 : return NULL;
29572 : }
29573 :
29574 :
29575 1 : SWIGINTERN PyObject *_wrap_layerObj_getFilterString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29576 : PyObject *resultobj = 0;
29577 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29578 1 : void *argp1 = 0 ;
29579 : int res1 = 0 ;
29580 1 : PyObject * obj0 = 0 ;
29581 : char *result = 0 ;
29582 :
29583 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getFilterString",&obj0)) SWIG_fail;
29584 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29585 1 : if (!SWIG_IsOK(res1)) {
29586 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getFilterString" "', argument " "1"" of type '" "struct layerObj *""'");
29587 : }
29588 1 : arg1 = (struct layerObj *)(argp1);
29589 : {
29590 : result = (char *)layerObj_getFilterString(arg1); {
29591 1 : errorObj *ms_error = msGetErrorObj();
29592 :
29593 1 : switch(ms_error->code) {
29594 : case MS_NOERR:
29595 : break;
29596 0 : case MS_NOTFOUND:
29597 0 : msResetErrorList();
29598 0 : break;
29599 : case -1:
29600 : break;
29601 0 : case MS_IOERR:
29602 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29603 0 : _raise_ms_exception();
29604 0 : msResetErrorList();
29605 0 : return NULL;
29606 : }
29607 : default:
29608 0 : _raise_ms_exception();
29609 0 : msResetErrorList();
29610 0 : return NULL;
29611 : }
29612 :
29613 : }
29614 : }
29615 1 : resultobj = SWIG_FromCharPtr((const char *)result);
29616 1 : free((char*)result);
29617 1 : return resultobj;
29618 0 : fail:
29619 : return NULL;
29620 : }
29621 :
29622 :
29623 0 : SWIGINTERN PyObject *_wrap_layerObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29624 : PyObject *resultobj = 0;
29625 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29626 : char *arg2 = (char *) 0 ;
29627 0 : void *argp1 = 0 ;
29628 : int res1 = 0 ;
29629 : int res2 ;
29630 0 : char *buf2 = 0 ;
29631 0 : int alloc2 = 0 ;
29632 0 : PyObject * obj0 = 0 ;
29633 0 : PyObject * obj1 = 0 ;
29634 : int result;
29635 :
29636 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
29637 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29638 0 : if (!SWIG_IsOK(res1)) {
29639 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setWKTProjection" "', argument " "1"" of type '" "struct layerObj *""'");
29640 : }
29641 0 : arg1 = (struct layerObj *)(argp1);
29642 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29643 0 : if (!SWIG_IsOK(res2)) {
29644 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
29645 : }
29646 0 : arg2 = (char *)(buf2);
29647 : {
29648 : result = (int)layerObj_setWKTProjection(arg1,arg2); {
29649 0 : errorObj *ms_error = msGetErrorObj();
29650 :
29651 0 : switch(ms_error->code) {
29652 : case MS_NOERR:
29653 : break;
29654 0 : case MS_NOTFOUND:
29655 0 : msResetErrorList();
29656 0 : break;
29657 : case -1:
29658 : break;
29659 0 : case MS_IOERR:
29660 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29661 0 : _raise_ms_exception();
29662 0 : msResetErrorList();
29663 0 : return NULL;
29664 : }
29665 : default:
29666 0 : _raise_ms_exception();
29667 0 : msResetErrorList();
29668 0 : return NULL;
29669 : }
29670 :
29671 : }
29672 : }
29673 : resultobj = SWIG_From_int((int)(result));
29674 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29675 : return resultobj;
29676 0 : fail:
29677 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29678 : return NULL;
29679 : }
29680 :
29681 :
29682 0 : SWIGINTERN PyObject *_wrap_layerObj_getProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29683 : PyObject *resultobj = 0;
29684 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29685 0 : void *argp1 = 0 ;
29686 : int res1 = 0 ;
29687 0 : PyObject * obj0 = 0 ;
29688 : char *result = 0 ;
29689 :
29690 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getProjection",&obj0)) SWIG_fail;
29691 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29692 0 : if (!SWIG_IsOK(res1)) {
29693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProjection" "', argument " "1"" of type '" "struct layerObj *""'");
29694 : }
29695 0 : arg1 = (struct layerObj *)(argp1);
29696 : {
29697 : result = (char *)layerObj_getProjection(arg1); {
29698 0 : errorObj *ms_error = msGetErrorObj();
29699 :
29700 0 : switch(ms_error->code) {
29701 : case MS_NOERR:
29702 : break;
29703 0 : case MS_NOTFOUND:
29704 0 : msResetErrorList();
29705 0 : break;
29706 : case -1:
29707 : break;
29708 0 : case MS_IOERR:
29709 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29710 0 : _raise_ms_exception();
29711 0 : msResetErrorList();
29712 0 : return NULL;
29713 : }
29714 : default:
29715 0 : _raise_ms_exception();
29716 0 : msResetErrorList();
29717 0 : return NULL;
29718 : }
29719 :
29720 : }
29721 : }
29722 0 : resultobj = SWIG_FromCharPtr((const char *)result);
29723 0 : free((char*)result);
29724 0 : return resultobj;
29725 0 : fail:
29726 : return NULL;
29727 : }
29728 :
29729 :
29730 1 : SWIGINTERN PyObject *_wrap_layerObj_setProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29731 : PyObject *resultobj = 0;
29732 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29733 : char *arg2 = (char *) 0 ;
29734 1 : void *argp1 = 0 ;
29735 : int res1 = 0 ;
29736 : int res2 ;
29737 1 : char *buf2 = 0 ;
29738 1 : int alloc2 = 0 ;
29739 1 : PyObject * obj0 = 0 ;
29740 1 : PyObject * obj1 = 0 ;
29741 : int result;
29742 :
29743 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setProjection",&obj0,&obj1)) SWIG_fail;
29744 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29745 1 : if (!SWIG_IsOK(res1)) {
29746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProjection" "', argument " "1"" of type '" "struct layerObj *""'");
29747 : }
29748 1 : arg1 = (struct layerObj *)(argp1);
29749 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
29750 1 : if (!SWIG_IsOK(res2)) {
29751 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProjection" "', argument " "2"" of type '" "char *""'");
29752 : }
29753 1 : arg2 = (char *)(buf2);
29754 : {
29755 : result = (int)layerObj_setProjection(arg1,arg2); {
29756 1 : errorObj *ms_error = msGetErrorObj();
29757 :
29758 1 : switch(ms_error->code) {
29759 : case MS_NOERR:
29760 : break;
29761 0 : case MS_NOTFOUND:
29762 0 : msResetErrorList();
29763 0 : break;
29764 : case -1:
29765 : break;
29766 0 : case MS_IOERR:
29767 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29768 0 : _raise_ms_exception();
29769 0 : msResetErrorList();
29770 0 : return NULL;
29771 : }
29772 : default:
29773 0 : _raise_ms_exception();
29774 0 : msResetErrorList();
29775 0 : return NULL;
29776 : }
29777 :
29778 : }
29779 : }
29780 : resultobj = SWIG_From_int((int)(result));
29781 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29782 : return resultobj;
29783 0 : fail:
29784 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
29785 : return NULL;
29786 : }
29787 :
29788 :
29789 1 : SWIGINTERN PyObject *_wrap_layerObj_addFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29790 : PyObject *resultobj = 0;
29791 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29792 : shapeObj *arg2 = (shapeObj *) 0 ;
29793 1 : void *argp1 = 0 ;
29794 : int res1 = 0 ;
29795 1 : void *argp2 = 0 ;
29796 : int res2 = 0 ;
29797 1 : PyObject * obj0 = 0 ;
29798 1 : PyObject * obj1 = 0 ;
29799 : int result;
29800 :
29801 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_addFeature",&obj0,&obj1)) SWIG_fail;
29802 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29803 1 : if (!SWIG_IsOK(res1)) {
29804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_addFeature" "', argument " "1"" of type '" "struct layerObj *""'");
29805 : }
29806 1 : arg1 = (struct layerObj *)(argp1);
29807 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
29808 1 : if (!SWIG_IsOK(res2)) {
29809 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_addFeature" "', argument " "2"" of type '" "shapeObj *""'");
29810 : }
29811 1 : arg2 = (shapeObj *)(argp2);
29812 : {
29813 1 : result = (int)layerObj_addFeature(arg1,arg2); {
29814 1 : errorObj *ms_error = msGetErrorObj();
29815 :
29816 1 : switch(ms_error->code) {
29817 : case MS_NOERR:
29818 : break;
29819 0 : case MS_NOTFOUND:
29820 0 : msResetErrorList();
29821 0 : break;
29822 : case -1:
29823 : break;
29824 0 : case MS_IOERR:
29825 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29826 0 : _raise_ms_exception();
29827 0 : msResetErrorList();
29828 0 : return NULL;
29829 : }
29830 : default:
29831 0 : _raise_ms_exception();
29832 0 : msResetErrorList();
29833 0 : return NULL;
29834 : }
29835 :
29836 : }
29837 : }
29838 : resultobj = SWIG_From_int((int)(result));
29839 1 : return resultobj;
29840 0 : fail:
29841 : return NULL;
29842 : }
29843 :
29844 :
29845 1 : SWIGINTERN PyObject *_wrap_layerObj_getNumFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29846 : PyObject *resultobj = 0;
29847 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29848 1 : void *argp1 = 0 ;
29849 : int res1 = 0 ;
29850 1 : PyObject * obj0 = 0 ;
29851 : int result;
29852 :
29853 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getNumFeatures",&obj0)) SWIG_fail;
29854 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29855 1 : if (!SWIG_IsOK(res1)) {
29856 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNumFeatures" "', argument " "1"" of type '" "struct layerObj *""'");
29857 : }
29858 1 : arg1 = (struct layerObj *)(argp1);
29859 : {
29860 : result = (int)layerObj_getNumFeatures(arg1); {
29861 1 : errorObj *ms_error = msGetErrorObj();
29862 :
29863 1 : switch(ms_error->code) {
29864 : case MS_NOERR:
29865 : break;
29866 0 : case MS_NOTFOUND:
29867 0 : msResetErrorList();
29868 0 : break;
29869 : case -1:
29870 : break;
29871 0 : case MS_IOERR:
29872 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29873 0 : _raise_ms_exception();
29874 0 : msResetErrorList();
29875 0 : return NULL;
29876 : }
29877 : default:
29878 1 : _raise_ms_exception();
29879 1 : msResetErrorList();
29880 1 : return NULL;
29881 : }
29882 :
29883 : }
29884 : }
29885 : resultobj = SWIG_From_int((int)(result));
29886 1 : return resultobj;
29887 0 : fail:
29888 : return NULL;
29889 : }
29890 :
29891 :
29892 1 : SWIGINTERN PyObject *_wrap_layerObj_getExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29893 : PyObject *resultobj = 0;
29894 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29895 1 : void *argp1 = 0 ;
29896 : int res1 = 0 ;
29897 1 : PyObject * obj0 = 0 ;
29898 : rectObj *result = 0 ;
29899 :
29900 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getExtent",&obj0)) SWIG_fail;
29901 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29902 1 : if (!SWIG_IsOK(res1)) {
29903 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getExtent" "', argument " "1"" of type '" "struct layerObj *""'");
29904 : }
29905 1 : arg1 = (struct layerObj *)(argp1);
29906 : {
29907 : result = (rectObj *)layerObj_getExtent(arg1); {
29908 1 : errorObj *ms_error = msGetErrorObj();
29909 :
29910 1 : switch(ms_error->code) {
29911 : case MS_NOERR:
29912 : break;
29913 0 : case MS_NOTFOUND:
29914 0 : msResetErrorList();
29915 0 : break;
29916 : case -1:
29917 : break;
29918 0 : case MS_IOERR:
29919 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
29920 0 : _raise_ms_exception();
29921 0 : msResetErrorList();
29922 0 : return NULL;
29923 : }
29924 : default:
29925 0 : _raise_ms_exception();
29926 0 : msResetErrorList();
29927 0 : return NULL;
29928 : }
29929 :
29930 : }
29931 : }
29932 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_OWN | 0 );
29933 1 : return resultobj;
29934 0 : fail:
29935 : return NULL;
29936 : }
29937 :
29938 :
29939 1 : SWIGINTERN PyObject *_wrap_layerObj_setExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29940 : PyObject *resultobj = 0;
29941 : struct layerObj *arg1 = (struct layerObj *) 0 ;
29942 : double arg2 = (double) -1.0 ;
29943 : double arg3 = (double) -1.0 ;
29944 : double arg4 = (double) -1.0 ;
29945 : double arg5 = (double) -1.0 ;
29946 1 : void *argp1 = 0 ;
29947 : int res1 = 0 ;
29948 : double val2 ;
29949 : int ecode2 = 0 ;
29950 : double val3 ;
29951 : int ecode3 = 0 ;
29952 : double val4 ;
29953 : int ecode4 = 0 ;
29954 : double val5 ;
29955 : int ecode5 = 0 ;
29956 1 : PyObject * obj0 = 0 ;
29957 1 : PyObject * obj1 = 0 ;
29958 1 : PyObject * obj2 = 0 ;
29959 1 : PyObject * obj3 = 0 ;
29960 1 : PyObject * obj4 = 0 ;
29961 : int result;
29962 :
29963 1 : if (!PyArg_ParseTuple(args,(char *)"O|OOOO:layerObj_setExtent",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
29964 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
29965 1 : if (!SWIG_IsOK(res1)) {
29966 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setExtent" "', argument " "1"" of type '" "struct layerObj *""'");
29967 : }
29968 1 : arg1 = (struct layerObj *)(argp1);
29969 1 : if (obj1) {
29970 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
29971 1 : if (!SWIG_IsOK(ecode2)) {
29972 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setExtent" "', argument " "2"" of type '" "double""'");
29973 : }
29974 1 : arg2 = (double)(val2);
29975 : }
29976 1 : if (obj2) {
29977 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
29978 1 : if (!SWIG_IsOK(ecode3)) {
29979 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_setExtent" "', argument " "3"" of type '" "double""'");
29980 : }
29981 1 : arg3 = (double)(val3);
29982 : }
29983 1 : if (obj3) {
29984 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
29985 1 : if (!SWIG_IsOK(ecode4)) {
29986 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_setExtent" "', argument " "4"" of type '" "double""'");
29987 : }
29988 1 : arg4 = (double)(val4);
29989 : }
29990 1 : if (obj4) {
29991 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
29992 1 : if (!SWIG_IsOK(ecode5)) {
29993 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_setExtent" "', argument " "5"" of type '" "double""'");
29994 : }
29995 1 : arg5 = (double)(val5);
29996 : }
29997 : {
29998 1 : result = (int)layerObj_setExtent(arg1,arg2,arg3,arg4,arg5); {
29999 1 : errorObj *ms_error = msGetErrorObj();
30000 :
30001 1 : switch(ms_error->code) {
30002 : case MS_NOERR:
30003 : break;
30004 0 : case MS_NOTFOUND:
30005 0 : msResetErrorList();
30006 0 : break;
30007 : case -1:
30008 : break;
30009 0 : case MS_IOERR:
30010 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30011 0 : _raise_ms_exception();
30012 0 : msResetErrorList();
30013 0 : return NULL;
30014 : }
30015 : default:
30016 0 : _raise_ms_exception();
30017 0 : msResetErrorList();
30018 0 : return NULL;
30019 : }
30020 :
30021 : }
30022 : }
30023 : resultobj = SWIG_From_int((int)(result));
30024 1 : return resultobj;
30025 0 : fail:
30026 : return NULL;
30027 : }
30028 :
30029 :
30030 0 : SWIGINTERN PyObject *_wrap_layerObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30031 : PyObject *resultobj = 0;
30032 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30033 : char *arg2 = (char *) 0 ;
30034 0 : void *argp1 = 0 ;
30035 : int res1 = 0 ;
30036 : int res2 ;
30037 0 : char *buf2 = 0 ;
30038 0 : int alloc2 = 0 ;
30039 0 : PyObject * obj0 = 0 ;
30040 0 : PyObject * obj1 = 0 ;
30041 : char *result = 0 ;
30042 :
30043 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getMetaData",&obj0,&obj1)) SWIG_fail;
30044 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30045 0 : if (!SWIG_IsOK(res1)) {
30046 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getMetaData" "', argument " "1"" of type '" "struct layerObj *""'");
30047 : }
30048 0 : arg1 = (struct layerObj *)(argp1);
30049 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30050 0 : if (!SWIG_IsOK(res2)) {
30051 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getMetaData" "', argument " "2"" of type '" "char *""'");
30052 : }
30053 0 : arg2 = (char *)(buf2);
30054 : {
30055 0 : result = (char *)layerObj_getMetaData(arg1,arg2); {
30056 0 : errorObj *ms_error = msGetErrorObj();
30057 :
30058 0 : switch(ms_error->code) {
30059 : case MS_NOERR:
30060 : break;
30061 0 : case MS_NOTFOUND:
30062 0 : msResetErrorList();
30063 0 : break;
30064 : case -1:
30065 : break;
30066 0 : case MS_IOERR:
30067 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30068 0 : _raise_ms_exception();
30069 0 : msResetErrorList();
30070 0 : return NULL;
30071 : }
30072 : default:
30073 0 : _raise_ms_exception();
30074 0 : msResetErrorList();
30075 0 : return NULL;
30076 : }
30077 :
30078 : }
30079 : }
30080 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30081 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30082 : return resultobj;
30083 0 : fail:
30084 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30085 : return NULL;
30086 : }
30087 :
30088 :
30089 0 : SWIGINTERN PyObject *_wrap_layerObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30090 : PyObject *resultobj = 0;
30091 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30092 : char *arg2 = (char *) 0 ;
30093 : char *arg3 = (char *) 0 ;
30094 0 : void *argp1 = 0 ;
30095 : int res1 = 0 ;
30096 : int res2 ;
30097 0 : char *buf2 = 0 ;
30098 0 : int alloc2 = 0 ;
30099 : int res3 ;
30100 0 : char *buf3 = 0 ;
30101 0 : int alloc3 = 0 ;
30102 0 : PyObject * obj0 = 0 ;
30103 0 : PyObject * obj1 = 0 ;
30104 0 : PyObject * obj2 = 0 ;
30105 : int result;
30106 :
30107 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
30108 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30109 0 : if (!SWIG_IsOK(res1)) {
30110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setMetaData" "', argument " "1"" of type '" "struct layerObj *""'");
30111 : }
30112 0 : arg1 = (struct layerObj *)(argp1);
30113 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30114 0 : if (!SWIG_IsOK(res2)) {
30115 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setMetaData" "', argument " "2"" of type '" "char *""'");
30116 : }
30117 0 : arg2 = (char *)(buf2);
30118 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
30119 0 : if (!SWIG_IsOK(res3)) {
30120 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setMetaData" "', argument " "3"" of type '" "char *""'");
30121 : }
30122 0 : arg3 = (char *)(buf3);
30123 : {
30124 : result = (int)layerObj_setMetaData(arg1,arg2,arg3); {
30125 0 : errorObj *ms_error = msGetErrorObj();
30126 :
30127 0 : switch(ms_error->code) {
30128 : case MS_NOERR:
30129 : break;
30130 0 : case MS_NOTFOUND:
30131 0 : msResetErrorList();
30132 0 : break;
30133 : case -1:
30134 : break;
30135 0 : case MS_IOERR:
30136 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30137 0 : _raise_ms_exception();
30138 0 : msResetErrorList();
30139 0 : return NULL;
30140 : }
30141 : default:
30142 0 : _raise_ms_exception();
30143 0 : msResetErrorList();
30144 0 : return NULL;
30145 : }
30146 :
30147 : }
30148 : }
30149 : resultobj = SWIG_From_int((int)(result));
30150 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30151 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30152 : return resultobj;
30153 0 : fail:
30154 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30155 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30156 : return NULL;
30157 : }
30158 :
30159 :
30160 0 : SWIGINTERN PyObject *_wrap_layerObj_removeMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30161 : PyObject *resultobj = 0;
30162 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30163 : char *arg2 = (char *) 0 ;
30164 0 : void *argp1 = 0 ;
30165 : int res1 = 0 ;
30166 : int res2 ;
30167 0 : char *buf2 = 0 ;
30168 0 : int alloc2 = 0 ;
30169 0 : PyObject * obj0 = 0 ;
30170 0 : PyObject * obj1 = 0 ;
30171 : int result;
30172 :
30173 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_removeMetaData",&obj0,&obj1)) SWIG_fail;
30174 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30175 0 : if (!SWIG_IsOK(res1)) {
30176 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_removeMetaData" "', argument " "1"" of type '" "struct layerObj *""'");
30177 : }
30178 0 : arg1 = (struct layerObj *)(argp1);
30179 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30180 0 : if (!SWIG_IsOK(res2)) {
30181 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_removeMetaData" "', argument " "2"" of type '" "char *""'");
30182 : }
30183 0 : arg2 = (char *)(buf2);
30184 : {
30185 : result = (int)layerObj_removeMetaData(arg1,arg2); {
30186 0 : errorObj *ms_error = msGetErrorObj();
30187 :
30188 0 : switch(ms_error->code) {
30189 : case MS_NOERR:
30190 : break;
30191 0 : case MS_NOTFOUND:
30192 0 : msResetErrorList();
30193 0 : break;
30194 : case -1:
30195 : break;
30196 0 : case MS_IOERR:
30197 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30198 0 : _raise_ms_exception();
30199 0 : msResetErrorList();
30200 0 : return NULL;
30201 : }
30202 : default:
30203 0 : _raise_ms_exception();
30204 0 : msResetErrorList();
30205 0 : return NULL;
30206 : }
30207 :
30208 : }
30209 : }
30210 : resultobj = SWIG_From_int((int)(result));
30211 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30212 : return resultobj;
30213 0 : fail:
30214 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30215 : return NULL;
30216 : }
30217 :
30218 :
30219 1 : SWIGINTERN PyObject *_wrap_layerObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30220 : PyObject *resultobj = 0;
30221 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30222 1 : void *argp1 = 0 ;
30223 : int res1 = 0 ;
30224 1 : PyObject * obj0 = 0 ;
30225 : char *result = 0 ;
30226 :
30227 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
30228 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30229 1 : if (!SWIG_IsOK(res1)) {
30230 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct layerObj *""'");
30231 : }
30232 1 : arg1 = (struct layerObj *)(argp1);
30233 : {
30234 : result = (char *)layerObj_getFirstMetaDataKey(arg1); {
30235 1 : errorObj *ms_error = msGetErrorObj();
30236 :
30237 1 : switch(ms_error->code) {
30238 : case MS_NOERR:
30239 : break;
30240 0 : case MS_NOTFOUND:
30241 0 : msResetErrorList();
30242 0 : break;
30243 : case -1:
30244 : break;
30245 0 : case MS_IOERR:
30246 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30247 0 : _raise_ms_exception();
30248 0 : msResetErrorList();
30249 0 : return NULL;
30250 : }
30251 : default:
30252 0 : _raise_ms_exception();
30253 0 : msResetErrorList();
30254 0 : return NULL;
30255 : }
30256 :
30257 : }
30258 : }
30259 1 : resultobj = SWIG_FromCharPtr((const char *)result);
30260 1 : return resultobj;
30261 0 : fail:
30262 : return NULL;
30263 : }
30264 :
30265 :
30266 1 : SWIGINTERN PyObject *_wrap_layerObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30267 : PyObject *resultobj = 0;
30268 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30269 : char *arg2 = (char *) 0 ;
30270 1 : void *argp1 = 0 ;
30271 : int res1 = 0 ;
30272 : int res2 ;
30273 1 : char *buf2 = 0 ;
30274 1 : int alloc2 = 0 ;
30275 1 : PyObject * obj0 = 0 ;
30276 1 : PyObject * obj1 = 0 ;
30277 : char *result = 0 ;
30278 :
30279 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
30280 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30281 1 : if (!SWIG_IsOK(res1)) {
30282 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct layerObj *""'");
30283 : }
30284 1 : arg1 = (struct layerObj *)(argp1);
30285 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30286 1 : if (!SWIG_IsOK(res2)) {
30287 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
30288 : }
30289 1 : arg2 = (char *)(buf2);
30290 : {
30291 : result = (char *)layerObj_getNextMetaDataKey(arg1,arg2); {
30292 1 : errorObj *ms_error = msGetErrorObj();
30293 :
30294 1 : switch(ms_error->code) {
30295 : case MS_NOERR:
30296 : break;
30297 0 : case MS_NOTFOUND:
30298 0 : msResetErrorList();
30299 0 : break;
30300 : case -1:
30301 : break;
30302 0 : case MS_IOERR:
30303 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30304 0 : _raise_ms_exception();
30305 0 : msResetErrorList();
30306 0 : return NULL;
30307 : }
30308 : default:
30309 0 : _raise_ms_exception();
30310 0 : msResetErrorList();
30311 0 : return NULL;
30312 : }
30313 :
30314 : }
30315 : }
30316 1 : resultobj = SWIG_FromCharPtr((const char *)result);
30317 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30318 : return resultobj;
30319 0 : fail:
30320 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30321 : return NULL;
30322 : }
30323 :
30324 :
30325 0 : SWIGINTERN PyObject *_wrap_layerObj_getWMSFeatureInfoURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30326 : PyObject *resultobj = 0;
30327 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30328 : mapObj *arg2 = (mapObj *) 0 ;
30329 : int arg3 ;
30330 : int arg4 ;
30331 : int arg5 ;
30332 : char *arg6 = (char *) 0 ;
30333 0 : void *argp1 = 0 ;
30334 : int res1 = 0 ;
30335 0 : void *argp2 = 0 ;
30336 : int res2 = 0 ;
30337 : int val3 ;
30338 : int ecode3 = 0 ;
30339 : int val4 ;
30340 : int ecode4 = 0 ;
30341 : int val5 ;
30342 : int ecode5 = 0 ;
30343 : int res6 ;
30344 0 : char *buf6 = 0 ;
30345 0 : int alloc6 = 0 ;
30346 0 : PyObject * obj0 = 0 ;
30347 0 : PyObject * obj1 = 0 ;
30348 0 : PyObject * obj2 = 0 ;
30349 0 : PyObject * obj3 = 0 ;
30350 0 : PyObject * obj4 = 0 ;
30351 0 : PyObject * obj5 = 0 ;
30352 : char *result = 0 ;
30353 :
30354 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:layerObj_getWMSFeatureInfoURL",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30355 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30356 0 : if (!SWIG_IsOK(res1)) {
30357 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "1"" of type '" "struct layerObj *""'");
30358 : }
30359 0 : arg1 = (struct layerObj *)(argp1);
30360 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
30361 0 : if (!SWIG_IsOK(res2)) {
30362 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "2"" of type '" "mapObj *""'");
30363 : }
30364 0 : arg2 = (mapObj *)(argp2);
30365 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
30366 0 : if (!SWIG_IsOK(ecode3)) {
30367 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "3"" of type '" "int""'");
30368 : }
30369 : arg3 = (int)(val3);
30370 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
30371 0 : if (!SWIG_IsOK(ecode4)) {
30372 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "4"" of type '" "int""'");
30373 : }
30374 : arg4 = (int)(val4);
30375 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
30376 0 : if (!SWIG_IsOK(ecode5)) {
30377 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "5"" of type '" "int""'");
30378 : }
30379 : arg5 = (int)(val5);
30380 0 : res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
30381 0 : if (!SWIG_IsOK(res6)) {
30382 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "layerObj_getWMSFeatureInfoURL" "', argument " "6"" of type '" "char *""'");
30383 : }
30384 0 : arg6 = (char *)(buf6);
30385 : {
30386 : result = (char *)layerObj_getWMSFeatureInfoURL(arg1,arg2,arg3,arg4,arg5,arg6); {
30387 0 : errorObj *ms_error = msGetErrorObj();
30388 :
30389 0 : switch(ms_error->code) {
30390 : case MS_NOERR:
30391 : break;
30392 0 : case MS_NOTFOUND:
30393 0 : msResetErrorList();
30394 0 : break;
30395 : case -1:
30396 : break;
30397 0 : case MS_IOERR:
30398 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30399 0 : _raise_ms_exception();
30400 0 : msResetErrorList();
30401 0 : return NULL;
30402 : }
30403 : default:
30404 0 : _raise_ms_exception();
30405 0 : msResetErrorList();
30406 0 : return NULL;
30407 : }
30408 :
30409 : }
30410 : }
30411 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30412 0 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
30413 0 : free((char*)result);
30414 0 : return resultobj;
30415 0 : fail:
30416 0 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
30417 : return NULL;
30418 : }
30419 :
30420 :
30421 0 : SWIGINTERN PyObject *_wrap_layerObj_executeWFSGetFeature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30422 : PyObject *resultobj = 0;
30423 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30424 : layerObj *arg2 = (layerObj *) 0 ;
30425 0 : void *argp1 = 0 ;
30426 : int res1 = 0 ;
30427 0 : void *argp2 = 0 ;
30428 : int res2 = 0 ;
30429 0 : PyObject * obj0 = 0 ;
30430 0 : PyObject * obj1 = 0 ;
30431 : char *result = 0 ;
30432 :
30433 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_executeWFSGetFeature",&obj0,&obj1)) SWIG_fail;
30434 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30435 0 : if (!SWIG_IsOK(res1)) {
30436 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_executeWFSGetFeature" "', argument " "1"" of type '" "struct layerObj *""'");
30437 : }
30438 : arg1 = (struct layerObj *)(argp1);
30439 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_layerObj, 0 | 0 );
30440 0 : if (!SWIG_IsOK(res2)) {
30441 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_executeWFSGetFeature" "', argument " "2"" of type '" "layerObj *""'");
30442 : }
30443 0 : arg2 = (layerObj *)(argp2);
30444 : {
30445 : result = (char *)layerObj_executeWFSGetFeature(arg1,arg2); {
30446 0 : errorObj *ms_error = msGetErrorObj();
30447 :
30448 0 : switch(ms_error->code) {
30449 : case MS_NOERR:
30450 : break;
30451 0 : case MS_NOTFOUND:
30452 0 : msResetErrorList();
30453 0 : break;
30454 : case -1:
30455 : break;
30456 0 : case MS_IOERR:
30457 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30458 0 : _raise_ms_exception();
30459 0 : msResetErrorList();
30460 0 : return NULL;
30461 : }
30462 : default:
30463 0 : _raise_ms_exception();
30464 0 : msResetErrorList();
30465 0 : return NULL;
30466 : }
30467 :
30468 : }
30469 : }
30470 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30471 0 : free((char*)result);
30472 0 : return resultobj;
30473 0 : fail:
30474 : return NULL;
30475 : }
30476 :
30477 :
30478 0 : SWIGINTERN PyObject *_wrap_layerObj_applySLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30479 : PyObject *resultobj = 0;
30480 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30481 : char *arg2 = (char *) 0 ;
30482 : char *arg3 = (char *) 0 ;
30483 0 : void *argp1 = 0 ;
30484 : int res1 = 0 ;
30485 : int res2 ;
30486 0 : char *buf2 = 0 ;
30487 0 : int alloc2 = 0 ;
30488 : int res3 ;
30489 0 : char *buf3 = 0 ;
30490 0 : int alloc3 = 0 ;
30491 0 : PyObject * obj0 = 0 ;
30492 0 : PyObject * obj1 = 0 ;
30493 0 : PyObject * obj2 = 0 ;
30494 : int result;
30495 :
30496 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_applySLD",&obj0,&obj1,&obj2)) SWIG_fail;
30497 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30498 0 : if (!SWIG_IsOK(res1)) {
30499 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_applySLD" "', argument " "1"" of type '" "struct layerObj *""'");
30500 : }
30501 0 : arg1 = (struct layerObj *)(argp1);
30502 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30503 0 : if (!SWIG_IsOK(res2)) {
30504 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_applySLD" "', argument " "2"" of type '" "char *""'");
30505 : }
30506 0 : arg2 = (char *)(buf2);
30507 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
30508 0 : if (!SWIG_IsOK(res3)) {
30509 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_applySLD" "', argument " "3"" of type '" "char *""'");
30510 : }
30511 0 : arg3 = (char *)(buf3);
30512 : {
30513 0 : result = (int)layerObj_applySLD(arg1,arg2,arg3); {
30514 0 : errorObj *ms_error = msGetErrorObj();
30515 :
30516 0 : switch(ms_error->code) {
30517 : case MS_NOERR:
30518 : break;
30519 0 : case MS_NOTFOUND:
30520 0 : msResetErrorList();
30521 0 : break;
30522 : case -1:
30523 : break;
30524 0 : case MS_IOERR:
30525 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30526 0 : _raise_ms_exception();
30527 0 : msResetErrorList();
30528 0 : return NULL;
30529 : }
30530 : default:
30531 0 : _raise_ms_exception();
30532 0 : msResetErrorList();
30533 0 : return NULL;
30534 : }
30535 :
30536 : }
30537 : }
30538 : resultobj = SWIG_From_int((int)(result));
30539 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30540 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30541 : return resultobj;
30542 0 : fail:
30543 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30544 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30545 : return NULL;
30546 : }
30547 :
30548 :
30549 0 : SWIGINTERN PyObject *_wrap_layerObj_applySLDURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30550 : PyObject *resultobj = 0;
30551 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30552 : char *arg2 = (char *) 0 ;
30553 : char *arg3 = (char *) 0 ;
30554 0 : void *argp1 = 0 ;
30555 : int res1 = 0 ;
30556 : int res2 ;
30557 0 : char *buf2 = 0 ;
30558 0 : int alloc2 = 0 ;
30559 : int res3 ;
30560 0 : char *buf3 = 0 ;
30561 0 : int alloc3 = 0 ;
30562 0 : PyObject * obj0 = 0 ;
30563 0 : PyObject * obj1 = 0 ;
30564 0 : PyObject * obj2 = 0 ;
30565 : int result;
30566 :
30567 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_applySLDURL",&obj0,&obj1,&obj2)) SWIG_fail;
30568 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30569 0 : if (!SWIG_IsOK(res1)) {
30570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_applySLDURL" "', argument " "1"" of type '" "struct layerObj *""'");
30571 : }
30572 0 : arg1 = (struct layerObj *)(argp1);
30573 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30574 0 : if (!SWIG_IsOK(res2)) {
30575 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_applySLDURL" "', argument " "2"" of type '" "char *""'");
30576 : }
30577 0 : arg2 = (char *)(buf2);
30578 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
30579 0 : if (!SWIG_IsOK(res3)) {
30580 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_applySLDURL" "', argument " "3"" of type '" "char *""'");
30581 : }
30582 0 : arg3 = (char *)(buf3);
30583 : {
30584 0 : result = (int)layerObj_applySLDURL(arg1,arg2,arg3); {
30585 0 : errorObj *ms_error = msGetErrorObj();
30586 :
30587 0 : switch(ms_error->code) {
30588 : case MS_NOERR:
30589 : break;
30590 0 : case MS_NOTFOUND:
30591 0 : msResetErrorList();
30592 0 : break;
30593 : case -1:
30594 : break;
30595 0 : case MS_IOERR:
30596 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30597 0 : _raise_ms_exception();
30598 0 : msResetErrorList();
30599 0 : return NULL;
30600 : }
30601 : default:
30602 0 : _raise_ms_exception();
30603 0 : msResetErrorList();
30604 0 : return NULL;
30605 : }
30606 :
30607 : }
30608 : }
30609 : resultobj = SWIG_From_int((int)(result));
30610 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30611 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30612 : return resultobj;
30613 0 : fail:
30614 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30615 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30616 : return NULL;
30617 : }
30618 :
30619 :
30620 0 : SWIGINTERN PyObject *_wrap_layerObj_generateSLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30621 : PyObject *resultobj = 0;
30622 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30623 0 : void *argp1 = 0 ;
30624 : int res1 = 0 ;
30625 0 : PyObject * obj0 = 0 ;
30626 : char *result = 0 ;
30627 :
30628 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_generateSLD",&obj0)) SWIG_fail;
30629 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30630 0 : if (!SWIG_IsOK(res1)) {
30631 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_generateSLD" "', argument " "1"" of type '" "struct layerObj *""'");
30632 : }
30633 0 : arg1 = (struct layerObj *)(argp1);
30634 : {
30635 0 : result = (char *)layerObj_generateSLD(arg1); {
30636 0 : errorObj *ms_error = msGetErrorObj();
30637 :
30638 0 : switch(ms_error->code) {
30639 : case MS_NOERR:
30640 : break;
30641 0 : case MS_NOTFOUND:
30642 0 : msResetErrorList();
30643 0 : break;
30644 : case -1:
30645 : break;
30646 0 : case MS_IOERR:
30647 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30648 0 : _raise_ms_exception();
30649 0 : msResetErrorList();
30650 0 : return NULL;
30651 : }
30652 : default:
30653 0 : _raise_ms_exception();
30654 0 : msResetErrorList();
30655 0 : return NULL;
30656 : }
30657 :
30658 : }
30659 : }
30660 0 : resultobj = SWIG_FromCharPtr((const char *)result);
30661 0 : free((char*)result);
30662 0 : return resultobj;
30663 0 : fail:
30664 : return NULL;
30665 : }
30666 :
30667 :
30668 1 : SWIGINTERN PyObject *_wrap_layerObj_isVisible(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30669 : PyObject *resultobj = 0;
30670 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30671 1 : void *argp1 = 0 ;
30672 : int res1 = 0 ;
30673 1 : PyObject * obj0 = 0 ;
30674 : int result;
30675 :
30676 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_isVisible",&obj0)) SWIG_fail;
30677 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30678 1 : if (!SWIG_IsOK(res1)) {
30679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_isVisible" "', argument " "1"" of type '" "struct layerObj *""'");
30680 : }
30681 1 : arg1 = (struct layerObj *)(argp1);
30682 : {
30683 1 : result = (int)layerObj_isVisible(arg1); {
30684 1 : errorObj *ms_error = msGetErrorObj();
30685 :
30686 1 : switch(ms_error->code) {
30687 : case MS_NOERR:
30688 : break;
30689 0 : case MS_NOTFOUND:
30690 0 : msResetErrorList();
30691 0 : break;
30692 : case -1:
30693 : break;
30694 0 : case MS_IOERR:
30695 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30696 0 : _raise_ms_exception();
30697 0 : msResetErrorList();
30698 0 : return NULL;
30699 : }
30700 : default:
30701 0 : _raise_ms_exception();
30702 0 : msResetErrorList();
30703 0 : return NULL;
30704 : }
30705 :
30706 : }
30707 : }
30708 : resultobj = SWIG_From_int((int)(result));
30709 1 : return resultobj;
30710 0 : fail:
30711 : return NULL;
30712 : }
30713 :
30714 :
30715 0 : SWIGINTERN PyObject *_wrap_layerObj_moveClassUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30716 : PyObject *resultobj = 0;
30717 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30718 : int arg2 ;
30719 0 : void *argp1 = 0 ;
30720 : int res1 = 0 ;
30721 : int val2 ;
30722 : int ecode2 = 0 ;
30723 0 : PyObject * obj0 = 0 ;
30724 0 : PyObject * obj1 = 0 ;
30725 : int result;
30726 :
30727 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_moveClassUp",&obj0,&obj1)) SWIG_fail;
30728 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30729 0 : if (!SWIG_IsOK(res1)) {
30730 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_moveClassUp" "', argument " "1"" of type '" "struct layerObj *""'");
30731 : }
30732 0 : arg1 = (struct layerObj *)(argp1);
30733 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30734 0 : if (!SWIG_IsOK(ecode2)) {
30735 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_moveClassUp" "', argument " "2"" of type '" "int""'");
30736 : }
30737 : arg2 = (int)(val2);
30738 : {
30739 : result = (int)layerObj_moveClassUp(arg1,arg2); {
30740 0 : errorObj *ms_error = msGetErrorObj();
30741 :
30742 0 : switch(ms_error->code) {
30743 : case MS_NOERR:
30744 : break;
30745 0 : case MS_NOTFOUND:
30746 0 : msResetErrorList();
30747 0 : break;
30748 : case -1:
30749 : break;
30750 0 : case MS_IOERR:
30751 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30752 0 : _raise_ms_exception();
30753 0 : msResetErrorList();
30754 0 : return NULL;
30755 : }
30756 : default:
30757 0 : _raise_ms_exception();
30758 0 : msResetErrorList();
30759 0 : return NULL;
30760 : }
30761 :
30762 : }
30763 : }
30764 : resultobj = SWIG_From_int((int)(result));
30765 0 : return resultobj;
30766 0 : fail:
30767 : return NULL;
30768 : }
30769 :
30770 :
30771 0 : SWIGINTERN PyObject *_wrap_layerObj_moveClassDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30772 : PyObject *resultobj = 0;
30773 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30774 : int arg2 ;
30775 0 : void *argp1 = 0 ;
30776 : int res1 = 0 ;
30777 : int val2 ;
30778 : int ecode2 = 0 ;
30779 0 : PyObject * obj0 = 0 ;
30780 0 : PyObject * obj1 = 0 ;
30781 : int result;
30782 :
30783 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_moveClassDown",&obj0,&obj1)) SWIG_fail;
30784 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30785 0 : if (!SWIG_IsOK(res1)) {
30786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_moveClassDown" "', argument " "1"" of type '" "struct layerObj *""'");
30787 : }
30788 0 : arg1 = (struct layerObj *)(argp1);
30789 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
30790 0 : if (!SWIG_IsOK(ecode2)) {
30791 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_moveClassDown" "', argument " "2"" of type '" "int""'");
30792 : }
30793 : arg2 = (int)(val2);
30794 : {
30795 : result = (int)layerObj_moveClassDown(arg1,arg2); {
30796 0 : errorObj *ms_error = msGetErrorObj();
30797 :
30798 0 : switch(ms_error->code) {
30799 : case MS_NOERR:
30800 : break;
30801 0 : case MS_NOTFOUND:
30802 0 : msResetErrorList();
30803 0 : break;
30804 : case -1:
30805 : break;
30806 0 : case MS_IOERR:
30807 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30808 0 : _raise_ms_exception();
30809 0 : msResetErrorList();
30810 0 : return NULL;
30811 : }
30812 : default:
30813 0 : _raise_ms_exception();
30814 0 : msResetErrorList();
30815 0 : return NULL;
30816 : }
30817 :
30818 : }
30819 : }
30820 : resultobj = SWIG_From_int((int)(result));
30821 0 : return resultobj;
30822 0 : fail:
30823 : return NULL;
30824 : }
30825 :
30826 :
30827 0 : SWIGINTERN PyObject *_wrap_layerObj_setProcessingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30828 : PyObject *resultobj = 0;
30829 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30830 : char *arg2 = (char *) 0 ;
30831 : char *arg3 = (char *) 0 ;
30832 0 : void *argp1 = 0 ;
30833 : int res1 = 0 ;
30834 : int res2 ;
30835 0 : char *buf2 = 0 ;
30836 0 : int alloc2 = 0 ;
30837 : int res3 ;
30838 0 : char *buf3 = 0 ;
30839 0 : int alloc3 = 0 ;
30840 0 : PyObject * obj0 = 0 ;
30841 0 : PyObject * obj1 = 0 ;
30842 0 : PyObject * obj2 = 0 ;
30843 :
30844 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setProcessingKey",&obj0,&obj1,&obj2)) SWIG_fail;
30845 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30846 0 : if (!SWIG_IsOK(res1)) {
30847 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProcessingKey" "', argument " "1"" of type '" "struct layerObj *""'");
30848 : }
30849 0 : arg1 = (struct layerObj *)(argp1);
30850 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30851 0 : if (!SWIG_IsOK(res2)) {
30852 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProcessingKey" "', argument " "2"" of type '" "char const *""'");
30853 : }
30854 0 : arg2 = (char *)(buf2);
30855 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
30856 0 : if (!SWIG_IsOK(res3)) {
30857 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setProcessingKey" "', argument " "3"" of type '" "char const *""'");
30858 : }
30859 0 : arg3 = (char *)(buf3);
30860 : {
30861 : layerObj_setProcessingKey(arg1,(char const *)arg2,(char const *)arg3); {
30862 0 : errorObj *ms_error = msGetErrorObj();
30863 :
30864 0 : switch(ms_error->code) {
30865 : case MS_NOERR:
30866 : break;
30867 0 : case MS_NOTFOUND:
30868 0 : msResetErrorList();
30869 0 : break;
30870 : case -1:
30871 : break;
30872 0 : case MS_IOERR:
30873 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30874 0 : _raise_ms_exception();
30875 0 : msResetErrorList();
30876 0 : return NULL;
30877 : }
30878 : default:
30879 0 : _raise_ms_exception();
30880 0 : msResetErrorList();
30881 0 : return NULL;
30882 : }
30883 :
30884 : }
30885 : }
30886 : resultobj = SWIG_Py_Void();
30887 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30888 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30889 : return resultobj;
30890 0 : fail:
30891 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30892 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
30893 : return NULL;
30894 : }
30895 :
30896 :
30897 1 : SWIGINTERN PyObject *_wrap_layerObj_setProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30898 : PyObject *resultobj = 0;
30899 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30900 : char *arg2 = (char *) 0 ;
30901 1 : void *argp1 = 0 ;
30902 : int res1 = 0 ;
30903 : int res2 ;
30904 1 : char *buf2 = 0 ;
30905 1 : int alloc2 = 0 ;
30906 1 : PyObject * obj0 = 0 ;
30907 1 : PyObject * obj1 = 0 ;
30908 :
30909 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setProcessing",&obj0,&obj1)) SWIG_fail;
30910 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30911 1 : if (!SWIG_IsOK(res1)) {
30912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setProcessing" "', argument " "1"" of type '" "struct layerObj *""'");
30913 : }
30914 1 : arg1 = (struct layerObj *)(argp1);
30915 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30916 1 : if (!SWIG_IsOK(res2)) {
30917 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setProcessing" "', argument " "2"" of type '" "char const *""'");
30918 : }
30919 1 : arg2 = (char *)(buf2);
30920 : {
30921 : layerObj_setProcessing(arg1,(char const *)arg2); {
30922 1 : errorObj *ms_error = msGetErrorObj();
30923 :
30924 1 : switch(ms_error->code) {
30925 : case MS_NOERR:
30926 : break;
30927 0 : case MS_NOTFOUND:
30928 0 : msResetErrorList();
30929 0 : break;
30930 : case -1:
30931 : break;
30932 0 : case MS_IOERR:
30933 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30934 0 : _raise_ms_exception();
30935 0 : msResetErrorList();
30936 0 : return NULL;
30937 : }
30938 : default:
30939 0 : _raise_ms_exception();
30940 0 : msResetErrorList();
30941 0 : return NULL;
30942 : }
30943 :
30944 : }
30945 : }
30946 : resultobj = SWIG_Py_Void();
30947 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30948 : return resultobj;
30949 0 : fail:
30950 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
30951 : return NULL;
30952 : }
30953 :
30954 :
30955 0 : SWIGINTERN PyObject *_wrap_layerObj_addProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30956 : PyObject *resultobj = 0;
30957 : struct layerObj *arg1 = (struct layerObj *) 0 ;
30958 : char *arg2 = (char *) 0 ;
30959 0 : void *argp1 = 0 ;
30960 : int res1 = 0 ;
30961 : int res2 ;
30962 0 : char *buf2 = 0 ;
30963 0 : int alloc2 = 0 ;
30964 0 : PyObject * obj0 = 0 ;
30965 0 : PyObject * obj1 = 0 ;
30966 :
30967 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_addProcessing",&obj0,&obj1)) SWIG_fail;
30968 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
30969 0 : if (!SWIG_IsOK(res1)) {
30970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_addProcessing" "', argument " "1"" of type '" "struct layerObj *""'");
30971 : }
30972 0 : arg1 = (struct layerObj *)(argp1);
30973 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
30974 0 : if (!SWIG_IsOK(res2)) {
30975 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_addProcessing" "', argument " "2"" of type '" "char const *""'");
30976 : }
30977 0 : arg2 = (char *)(buf2);
30978 : {
30979 : layerObj_addProcessing(arg1,(char const *)arg2); {
30980 0 : errorObj *ms_error = msGetErrorObj();
30981 :
30982 0 : switch(ms_error->code) {
30983 : case MS_NOERR:
30984 : break;
30985 0 : case MS_NOTFOUND:
30986 0 : msResetErrorList();
30987 0 : break;
30988 : case -1:
30989 : break;
30990 0 : case MS_IOERR:
30991 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
30992 0 : _raise_ms_exception();
30993 0 : msResetErrorList();
30994 0 : return NULL;
30995 : }
30996 : default:
30997 0 : _raise_ms_exception();
30998 0 : msResetErrorList();
30999 0 : return NULL;
31000 : }
31001 :
31002 : }
31003 : }
31004 : resultobj = SWIG_Py_Void();
31005 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31006 : return resultobj;
31007 0 : fail:
31008 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31009 : return NULL;
31010 : }
31011 :
31012 :
31013 1 : SWIGINTERN PyObject *_wrap_layerObj_getProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 : PyObject *resultobj = 0;
31015 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31016 : int arg2 ;
31017 1 : void *argp1 = 0 ;
31018 : int res1 = 0 ;
31019 : int val2 ;
31020 : int ecode2 = 0 ;
31021 1 : PyObject * obj0 = 0 ;
31022 1 : PyObject * obj1 = 0 ;
31023 : char *result = 0 ;
31024 :
31025 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getProcessing",&obj0,&obj1)) SWIG_fail;
31026 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31027 1 : if (!SWIG_IsOK(res1)) {
31028 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProcessing" "', argument " "1"" of type '" "struct layerObj *""'");
31029 : }
31030 1 : arg1 = (struct layerObj *)(argp1);
31031 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31032 1 : if (!SWIG_IsOK(ecode2)) {
31033 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getProcessing" "', argument " "2"" of type '" "int""'");
31034 : }
31035 : arg2 = (int)(val2);
31036 : {
31037 : result = (char *)layerObj_getProcessing(arg1,arg2); {
31038 1 : errorObj *ms_error = msGetErrorObj();
31039 :
31040 1 : switch(ms_error->code) {
31041 : case MS_NOERR:
31042 : break;
31043 0 : case MS_NOTFOUND:
31044 0 : msResetErrorList();
31045 0 : break;
31046 : case -1:
31047 : break;
31048 0 : case MS_IOERR:
31049 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31050 0 : _raise_ms_exception();
31051 0 : msResetErrorList();
31052 0 : return NULL;
31053 : }
31054 : default:
31055 0 : _raise_ms_exception();
31056 0 : msResetErrorList();
31057 0 : return NULL;
31058 : }
31059 :
31060 : }
31061 : }
31062 1 : resultobj = SWIG_FromCharPtr((const char *)result);
31063 1 : return resultobj;
31064 0 : fail:
31065 : return NULL;
31066 : }
31067 :
31068 :
31069 0 : SWIGINTERN PyObject *_wrap_layerObj_getProcessingKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 : PyObject *resultobj = 0;
31071 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31072 : char *arg2 = (char *) 0 ;
31073 0 : void *argp1 = 0 ;
31074 : int res1 = 0 ;
31075 : int res2 ;
31076 0 : char *buf2 = 0 ;
31077 0 : int alloc2 = 0 ;
31078 0 : PyObject * obj0 = 0 ;
31079 0 : PyObject * obj1 = 0 ;
31080 : char *result = 0 ;
31081 :
31082 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getProcessingKey",&obj0,&obj1)) SWIG_fail;
31083 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31084 0 : if (!SWIG_IsOK(res1)) {
31085 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getProcessingKey" "', argument " "1"" of type '" "struct layerObj *""'");
31086 : }
31087 0 : arg1 = (struct layerObj *)(argp1);
31088 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31089 0 : if (!SWIG_IsOK(res2)) {
31090 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getProcessingKey" "', argument " "2"" of type '" "char const *""'");
31091 : }
31092 0 : arg2 = (char *)(buf2);
31093 : {
31094 : result = (char *)layerObj_getProcessingKey(arg1,(char const *)arg2); {
31095 0 : errorObj *ms_error = msGetErrorObj();
31096 :
31097 0 : switch(ms_error->code) {
31098 : case MS_NOERR:
31099 : break;
31100 0 : case MS_NOTFOUND:
31101 0 : msResetErrorList();
31102 0 : break;
31103 : case -1:
31104 : break;
31105 0 : case MS_IOERR:
31106 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31107 0 : _raise_ms_exception();
31108 0 : msResetErrorList();
31109 0 : return NULL;
31110 : }
31111 : default:
31112 0 : _raise_ms_exception();
31113 0 : msResetErrorList();
31114 0 : return NULL;
31115 : }
31116 :
31117 : }
31118 : }
31119 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31120 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31121 : return resultobj;
31122 0 : fail:
31123 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31124 : return NULL;
31125 : }
31126 :
31127 :
31128 1 : SWIGINTERN PyObject *_wrap_layerObj_clearProcessing(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31129 : PyObject *resultobj = 0;
31130 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31131 1 : void *argp1 = 0 ;
31132 : int res1 = 0 ;
31133 1 : PyObject * obj0 = 0 ;
31134 : int result;
31135 :
31136 1 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_clearProcessing",&obj0)) SWIG_fail;
31137 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31138 1 : if (!SWIG_IsOK(res1)) {
31139 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_clearProcessing" "', argument " "1"" of type '" "struct layerObj *""'");
31140 : }
31141 1 : arg1 = (struct layerObj *)(argp1);
31142 : {
31143 : result = (int)layerObj_clearProcessing(arg1); {
31144 1 : errorObj *ms_error = msGetErrorObj();
31145 :
31146 1 : switch(ms_error->code) {
31147 : case MS_NOERR:
31148 : break;
31149 0 : case MS_NOTFOUND:
31150 0 : msResetErrorList();
31151 0 : break;
31152 : case -1:
31153 : break;
31154 0 : case MS_IOERR:
31155 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31156 0 : _raise_ms_exception();
31157 0 : msResetErrorList();
31158 0 : return NULL;
31159 : }
31160 : default:
31161 0 : _raise_ms_exception();
31162 0 : msResetErrorList();
31163 0 : return NULL;
31164 : }
31165 :
31166 : }
31167 : }
31168 : resultobj = SWIG_From_int((int)(result));
31169 1 : return resultobj;
31170 0 : fail:
31171 : return NULL;
31172 : }
31173 :
31174 :
31175 0 : SWIGINTERN PyObject *_wrap_layerObj_setConnectionType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31176 : PyObject *resultobj = 0;
31177 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31178 : int arg2 ;
31179 : char *arg3 = (char *) 0 ;
31180 0 : void *argp1 = 0 ;
31181 : int res1 = 0 ;
31182 : int val2 ;
31183 : int ecode2 = 0 ;
31184 : int res3 ;
31185 0 : char *buf3 = 0 ;
31186 0 : int alloc3 = 0 ;
31187 0 : PyObject * obj0 = 0 ;
31188 0 : PyObject * obj1 = 0 ;
31189 0 : PyObject * obj2 = 0 ;
31190 : int result;
31191 :
31192 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:layerObj_setConnectionType",&obj0,&obj1,&obj2)) SWIG_fail;
31193 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31194 0 : if (!SWIG_IsOK(res1)) {
31195 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setConnectionType" "', argument " "1"" of type '" "struct layerObj *""'");
31196 : }
31197 0 : arg1 = (struct layerObj *)(argp1);
31198 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31199 0 : if (!SWIG_IsOK(ecode2)) {
31200 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_setConnectionType" "', argument " "2"" of type '" "int""'");
31201 : }
31202 : arg2 = (int)(val2);
31203 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
31204 0 : if (!SWIG_IsOK(res3)) {
31205 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_setConnectionType" "', argument " "3"" of type '" "char const *""'");
31206 : }
31207 0 : arg3 = (char *)(buf3);
31208 : {
31209 0 : result = (int)layerObj_setConnectionType(arg1,arg2,(char const *)arg3); {
31210 0 : errorObj *ms_error = msGetErrorObj();
31211 :
31212 0 : switch(ms_error->code) {
31213 : case MS_NOERR:
31214 : break;
31215 0 : case MS_NOTFOUND:
31216 0 : msResetErrorList();
31217 0 : break;
31218 : case -1:
31219 : break;
31220 0 : case MS_IOERR:
31221 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31222 0 : _raise_ms_exception();
31223 0 : msResetErrorList();
31224 0 : return NULL;
31225 : }
31226 : default:
31227 0 : _raise_ms_exception();
31228 0 : msResetErrorList();
31229 0 : return NULL;
31230 : }
31231 :
31232 : }
31233 : }
31234 : resultobj = SWIG_From_int((int)(result));
31235 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
31236 : return resultobj;
31237 0 : fail:
31238 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
31239 : return NULL;
31240 : }
31241 :
31242 :
31243 0 : SWIGINTERN PyObject *_wrap_layerObj_getClassIndex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31244 : PyObject *resultobj = 0;
31245 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31246 : mapObj *arg2 = (mapObj *) 0 ;
31247 : shapeObj *arg3 = (shapeObj *) 0 ;
31248 : int *arg4 = (int *) NULL ;
31249 : int arg5 = (int) 0 ;
31250 0 : void *argp1 = 0 ;
31251 : int res1 = 0 ;
31252 0 : void *argp2 = 0 ;
31253 : int res2 = 0 ;
31254 0 : void *argp3 = 0 ;
31255 : int res3 = 0 ;
31256 0 : void *argp4 = 0 ;
31257 : int res4 = 0 ;
31258 : int val5 ;
31259 : int ecode5 = 0 ;
31260 0 : PyObject * obj0 = 0 ;
31261 0 : PyObject * obj1 = 0 ;
31262 0 : PyObject * obj2 = 0 ;
31263 0 : PyObject * obj3 = 0 ;
31264 0 : PyObject * obj4 = 0 ;
31265 : int result;
31266 :
31267 0 : if (!PyArg_ParseTuple(args,(char *)"OOO|OO:layerObj_getClassIndex",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31268 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31269 0 : if (!SWIG_IsOK(res1)) {
31270 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getClassIndex" "', argument " "1"" of type '" "struct layerObj *""'");
31271 : }
31272 0 : arg1 = (struct layerObj *)(argp1);
31273 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
31274 0 : if (!SWIG_IsOK(res2)) {
31275 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_getClassIndex" "', argument " "2"" of type '" "mapObj *""'");
31276 : }
31277 0 : arg2 = (mapObj *)(argp2);
31278 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 | 0 );
31279 0 : if (!SWIG_IsOK(res3)) {
31280 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "layerObj_getClassIndex" "', argument " "3"" of type '" "shapeObj *""'");
31281 : }
31282 0 : arg3 = (shapeObj *)(argp3);
31283 0 : if (obj3) {
31284 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_int, 0 | 0 );
31285 0 : if (!SWIG_IsOK(res4)) {
31286 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "layerObj_getClassIndex" "', argument " "4"" of type '" "int *""'");
31287 : }
31288 0 : arg4 = (int *)(argp4);
31289 : }
31290 0 : if (obj4) {
31291 : ecode5 = SWIG_AsVal_int(obj4, &val5);
31292 0 : if (!SWIG_IsOK(ecode5)) {
31293 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "layerObj_getClassIndex" "', argument " "5"" of type '" "int""'");
31294 : }
31295 : arg5 = (int)(val5);
31296 : }
31297 : {
31298 : result = (int)layerObj_getClassIndex(arg1,arg2,arg3,arg4,arg5); {
31299 0 : errorObj *ms_error = msGetErrorObj();
31300 :
31301 0 : switch(ms_error->code) {
31302 : case MS_NOERR:
31303 : break;
31304 0 : case MS_NOTFOUND:
31305 0 : msResetErrorList();
31306 0 : break;
31307 : case -1:
31308 : break;
31309 0 : case MS_IOERR:
31310 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31311 0 : _raise_ms_exception();
31312 0 : msResetErrorList();
31313 0 : return NULL;
31314 : }
31315 : default:
31316 0 : _raise_ms_exception();
31317 0 : msResetErrorList();
31318 0 : return NULL;
31319 : }
31320 :
31321 : }
31322 : }
31323 : resultobj = SWIG_From_int((int)(result));
31324 0 : return resultobj;
31325 0 : fail:
31326 : return NULL;
31327 : }
31328 :
31329 :
31330 0 : SWIGINTERN PyObject *_wrap_layerObj_getGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31331 : PyObject *resultobj = 0;
31332 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31333 0 : void *argp1 = 0 ;
31334 : int res1 = 0 ;
31335 0 : PyObject * obj0 = 0 ;
31336 : char *result = 0 ;
31337 :
31338 0 : if (!PyArg_ParseTuple(args,(char *)"O:layerObj_getGeomTransform",&obj0)) SWIG_fail;
31339 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31340 0 : if (!SWIG_IsOK(res1)) {
31341 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getGeomTransform" "', argument " "1"" of type '" "struct layerObj *""'");
31342 : }
31343 0 : arg1 = (struct layerObj *)(argp1);
31344 : {
31345 0 : result = (char *)layerObj_getGeomTransform(arg1); {
31346 0 : errorObj *ms_error = msGetErrorObj();
31347 :
31348 0 : switch(ms_error->code) {
31349 : case MS_NOERR:
31350 : break;
31351 0 : case MS_NOTFOUND:
31352 0 : msResetErrorList();
31353 0 : break;
31354 : case -1:
31355 : break;
31356 0 : case MS_IOERR:
31357 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31358 0 : _raise_ms_exception();
31359 0 : msResetErrorList();
31360 0 : return NULL;
31361 : }
31362 : default:
31363 0 : _raise_ms_exception();
31364 0 : msResetErrorList();
31365 0 : return NULL;
31366 : }
31367 :
31368 : }
31369 : }
31370 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31371 0 : return resultobj;
31372 0 : fail:
31373 : return NULL;
31374 : }
31375 :
31376 :
31377 0 : SWIGINTERN PyObject *_wrap_layerObj_setGeomTransform(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31378 : PyObject *resultobj = 0;
31379 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31380 : char *arg2 = (char *) 0 ;
31381 0 : void *argp1 = 0 ;
31382 : int res1 = 0 ;
31383 : int res2 ;
31384 0 : char *buf2 = 0 ;
31385 0 : int alloc2 = 0 ;
31386 0 : PyObject * obj0 = 0 ;
31387 0 : PyObject * obj1 = 0 ;
31388 :
31389 0 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_setGeomTransform",&obj0,&obj1)) SWIG_fail;
31390 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31391 0 : if (!SWIG_IsOK(res1)) {
31392 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_setGeomTransform" "', argument " "1"" of type '" "struct layerObj *""'");
31393 : }
31394 0 : arg1 = (struct layerObj *)(argp1);
31395 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31396 0 : if (!SWIG_IsOK(res2)) {
31397 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "layerObj_setGeomTransform" "', argument " "2"" of type '" "char *""'");
31398 : }
31399 0 : arg2 = (char *)(buf2);
31400 : {
31401 0 : layerObj_setGeomTransform(arg1,arg2); {
31402 0 : errorObj *ms_error = msGetErrorObj();
31403 :
31404 0 : switch(ms_error->code) {
31405 : case MS_NOERR:
31406 : break;
31407 0 : case MS_NOTFOUND:
31408 0 : msResetErrorList();
31409 0 : break;
31410 : case -1:
31411 : break;
31412 0 : case MS_IOERR:
31413 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31414 0 : _raise_ms_exception();
31415 0 : msResetErrorList();
31416 0 : return NULL;
31417 : }
31418 : default:
31419 0 : _raise_ms_exception();
31420 0 : msResetErrorList();
31421 0 : return NULL;
31422 : }
31423 :
31424 : }
31425 : }
31426 : resultobj = SWIG_Py_Void();
31427 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31428 : return resultobj;
31429 0 : fail:
31430 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31431 : return NULL;
31432 : }
31433 :
31434 :
31435 1 : SWIGINTERN PyObject *_wrap_layerObj_getItemType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 : PyObject *resultobj = 0;
31437 : struct layerObj *arg1 = (struct layerObj *) 0 ;
31438 : int arg2 ;
31439 1 : void *argp1 = 0 ;
31440 : int res1 = 0 ;
31441 : int val2 ;
31442 : int ecode2 = 0 ;
31443 1 : PyObject * obj0 = 0 ;
31444 1 : PyObject * obj1 = 0 ;
31445 : char *result = 0 ;
31446 :
31447 1 : if (!PyArg_ParseTuple(args,(char *)"OO:layerObj_getItemType",&obj0,&obj1)) SWIG_fail;
31448 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_layerObj, 0 | 0 );
31449 1 : if (!SWIG_IsOK(res1)) {
31450 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "layerObj_getItemType" "', argument " "1"" of type '" "struct layerObj *""'");
31451 : }
31452 1 : arg1 = (struct layerObj *)(argp1);
31453 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31454 1 : if (!SWIG_IsOK(ecode2)) {
31455 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "layerObj_getItemType" "', argument " "2"" of type '" "int""'");
31456 : }
31457 : arg2 = (int)(val2);
31458 : {
31459 1 : result = (char *)layerObj_getItemType(arg1,arg2); {
31460 1 : errorObj *ms_error = msGetErrorObj();
31461 :
31462 1 : switch(ms_error->code) {
31463 : case MS_NOERR:
31464 : break;
31465 0 : case MS_NOTFOUND:
31466 0 : msResetErrorList();
31467 0 : break;
31468 : case -1:
31469 : break;
31470 0 : case MS_IOERR:
31471 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
31472 0 : _raise_ms_exception();
31473 0 : msResetErrorList();
31474 0 : return NULL;
31475 : }
31476 : default:
31477 0 : _raise_ms_exception();
31478 0 : msResetErrorList();
31479 0 : return NULL;
31480 : }
31481 :
31482 : }
31483 : }
31484 1 : resultobj = SWIG_FromCharPtr((const char *)result);
31485 1 : return resultobj;
31486 0 : fail:
31487 : return NULL;
31488 : }
31489 :
31490 :
31491 1 : SWIGINTERN PyObject *layerObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31492 : PyObject *obj;
31493 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
31494 1 : SWIG_TypeNewClientData(SWIGTYPE_p_layerObj, SWIG_NewClientData(obj));
31495 1 : return SWIG_Py_Void();
31496 : }
31497 :
31498 0 : SWIGINTERN PyObject *_wrap_mapObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31499 : PyObject *resultobj = 0;
31500 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31501 : char *arg2 = (char *) 0 ;
31502 0 : void *argp1 = 0 ;
31503 : int res1 = 0 ;
31504 : int res2 ;
31505 0 : char *buf2 = 0 ;
31506 0 : int alloc2 = 0 ;
31507 0 : PyObject * obj0 = 0 ;
31508 0 : PyObject * obj1 = 0 ;
31509 :
31510 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_name_set",&obj0,&obj1)) SWIG_fail;
31511 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31512 0 : if (!SWIG_IsOK(res1)) {
31513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_name_set" "', argument " "1"" of type '" "struct mapObj *""'");
31514 : }
31515 0 : arg1 = (struct mapObj *)(argp1);
31516 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31517 0 : if (!SWIG_IsOK(res2)) {
31518 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_name_set" "', argument " "2"" of type '" "char *""'");
31519 : }
31520 0 : arg2 = (char *)(buf2);
31521 : {
31522 0 : if (arg1->name) free((char*)arg1->name);
31523 0 : if (arg2) {
31524 0 : arg1->name = (char *) malloc(strlen(arg2)+1);
31525 : strcpy((char*)arg1->name,arg2);
31526 : } else {
31527 0 : arg1->name = 0;
31528 : }
31529 : }
31530 : resultobj = SWIG_Py_Void();
31531 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31532 : return resultobj;
31533 0 : fail:
31534 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31535 : return NULL;
31536 : }
31537 :
31538 :
31539 1 : SWIGINTERN PyObject *_wrap_mapObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31540 : PyObject *resultobj = 0;
31541 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31542 1 : void *argp1 = 0 ;
31543 : int res1 = 0 ;
31544 1 : PyObject * obj0 = 0 ;
31545 : char *result = 0 ;
31546 :
31547 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_name_get",&obj0)) SWIG_fail;
31548 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31549 1 : if (!SWIG_IsOK(res1)) {
31550 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_name_get" "', argument " "1"" of type '" "struct mapObj *""'");
31551 : }
31552 1 : arg1 = (struct mapObj *)(argp1);
31553 1 : result = (char *) ((arg1)->name);
31554 1 : resultobj = SWIG_FromCharPtr((const char *)result);
31555 1 : return resultobj;
31556 0 : fail:
31557 : return NULL;
31558 : }
31559 :
31560 :
31561 0 : SWIGINTERN PyObject *_wrap_mapObj_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31562 : PyObject *resultobj = 0;
31563 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31564 : int arg2 ;
31565 0 : void *argp1 = 0 ;
31566 : int res1 = 0 ;
31567 : int val2 ;
31568 : int ecode2 = 0 ;
31569 0 : PyObject * obj0 = 0 ;
31570 0 : PyObject * obj1 = 0 ;
31571 :
31572 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_status_set",&obj0,&obj1)) SWIG_fail;
31573 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31574 0 : if (!SWIG_IsOK(res1)) {
31575 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_status_set" "', argument " "1"" of type '" "struct mapObj *""'");
31576 : }
31577 0 : arg1 = (struct mapObj *)(argp1);
31578 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31579 0 : if (!SWIG_IsOK(ecode2)) {
31580 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_status_set" "', argument " "2"" of type '" "int""'");
31581 : }
31582 : arg2 = (int)(val2);
31583 0 : if (arg1) (arg1)->status = arg2;
31584 : resultobj = SWIG_Py_Void();
31585 0 : return resultobj;
31586 0 : fail:
31587 : return NULL;
31588 : }
31589 :
31590 :
31591 0 : SWIGINTERN PyObject *_wrap_mapObj_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31592 : PyObject *resultobj = 0;
31593 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31594 0 : void *argp1 = 0 ;
31595 : int res1 = 0 ;
31596 0 : PyObject * obj0 = 0 ;
31597 : int result;
31598 :
31599 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_status_get",&obj0)) SWIG_fail;
31600 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31601 0 : if (!SWIG_IsOK(res1)) {
31602 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_status_get" "', argument " "1"" of type '" "struct mapObj *""'");
31603 : }
31604 0 : arg1 = (struct mapObj *)(argp1);
31605 0 : result = (int) ((arg1)->status);
31606 : resultobj = SWIG_From_int((int)(result));
31607 0 : return resultobj;
31608 0 : fail:
31609 : return NULL;
31610 : }
31611 :
31612 :
31613 1 : SWIGINTERN PyObject *_wrap_mapObj_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31614 : PyObject *resultobj = 0;
31615 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31616 : int arg2 ;
31617 1 : void *argp1 = 0 ;
31618 : int res1 = 0 ;
31619 : int val2 ;
31620 : int ecode2 = 0 ;
31621 1 : PyObject * obj0 = 0 ;
31622 1 : PyObject * obj1 = 0 ;
31623 :
31624 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_height_set",&obj0,&obj1)) SWIG_fail;
31625 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31626 1 : if (!SWIG_IsOK(res1)) {
31627 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_height_set" "', argument " "1"" of type '" "struct mapObj *""'");
31628 : }
31629 1 : arg1 = (struct mapObj *)(argp1);
31630 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31631 1 : if (!SWIG_IsOK(ecode2)) {
31632 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_height_set" "', argument " "2"" of type '" "int""'");
31633 : }
31634 : arg2 = (int)(val2);
31635 1 : if (arg1) (arg1)->height = arg2;
31636 : resultobj = SWIG_Py_Void();
31637 1 : return resultobj;
31638 0 : fail:
31639 : return NULL;
31640 : }
31641 :
31642 :
31643 0 : SWIGINTERN PyObject *_wrap_mapObj_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31644 : PyObject *resultobj = 0;
31645 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31646 0 : void *argp1 = 0 ;
31647 : int res1 = 0 ;
31648 0 : PyObject * obj0 = 0 ;
31649 : int result;
31650 :
31651 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_height_get",&obj0)) SWIG_fail;
31652 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31653 0 : if (!SWIG_IsOK(res1)) {
31654 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_height_get" "', argument " "1"" of type '" "struct mapObj *""'");
31655 : }
31656 0 : arg1 = (struct mapObj *)(argp1);
31657 0 : result = (int) ((arg1)->height);
31658 : resultobj = SWIG_From_int((int)(result));
31659 0 : return resultobj;
31660 0 : fail:
31661 : return NULL;
31662 : }
31663 :
31664 :
31665 1 : SWIGINTERN PyObject *_wrap_mapObj_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31666 : PyObject *resultobj = 0;
31667 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31668 : int arg2 ;
31669 1 : void *argp1 = 0 ;
31670 : int res1 = 0 ;
31671 : int val2 ;
31672 : int ecode2 = 0 ;
31673 1 : PyObject * obj0 = 0 ;
31674 1 : PyObject * obj1 = 0 ;
31675 :
31676 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_width_set",&obj0,&obj1)) SWIG_fail;
31677 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31678 1 : if (!SWIG_IsOK(res1)) {
31679 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_width_set" "', argument " "1"" of type '" "struct mapObj *""'");
31680 : }
31681 1 : arg1 = (struct mapObj *)(argp1);
31682 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31683 1 : if (!SWIG_IsOK(ecode2)) {
31684 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_width_set" "', argument " "2"" of type '" "int""'");
31685 : }
31686 : arg2 = (int)(val2);
31687 1 : if (arg1) (arg1)->width = arg2;
31688 : resultobj = SWIG_Py_Void();
31689 1 : return resultobj;
31690 0 : fail:
31691 : return NULL;
31692 : }
31693 :
31694 :
31695 0 : SWIGINTERN PyObject *_wrap_mapObj_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31696 : PyObject *resultobj = 0;
31697 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31698 0 : void *argp1 = 0 ;
31699 : int res1 = 0 ;
31700 0 : PyObject * obj0 = 0 ;
31701 : int result;
31702 :
31703 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_width_get",&obj0)) SWIG_fail;
31704 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31705 0 : if (!SWIG_IsOK(res1)) {
31706 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_width_get" "', argument " "1"" of type '" "struct mapObj *""'");
31707 : }
31708 0 : arg1 = (struct mapObj *)(argp1);
31709 0 : result = (int) ((arg1)->width);
31710 : resultobj = SWIG_From_int((int)(result));
31711 0 : return resultobj;
31712 0 : fail:
31713 : return NULL;
31714 : }
31715 :
31716 :
31717 0 : SWIGINTERN PyObject *_wrap_mapObj_maxsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31718 : PyObject *resultobj = 0;
31719 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31720 : int arg2 ;
31721 0 : void *argp1 = 0 ;
31722 : int res1 = 0 ;
31723 : int val2 ;
31724 : int ecode2 = 0 ;
31725 0 : PyObject * obj0 = 0 ;
31726 0 : PyObject * obj1 = 0 ;
31727 :
31728 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_maxsize_set",&obj0,&obj1)) SWIG_fail;
31729 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31730 0 : if (!SWIG_IsOK(res1)) {
31731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxsize_set" "', argument " "1"" of type '" "struct mapObj *""'");
31732 : }
31733 0 : arg1 = (struct mapObj *)(argp1);
31734 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31735 0 : if (!SWIG_IsOK(ecode2)) {
31736 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_maxsize_set" "', argument " "2"" of type '" "int""'");
31737 : }
31738 : arg2 = (int)(val2);
31739 0 : if (arg1) (arg1)->maxsize = arg2;
31740 : resultobj = SWIG_Py_Void();
31741 0 : return resultobj;
31742 0 : fail:
31743 : return NULL;
31744 : }
31745 :
31746 :
31747 0 : SWIGINTERN PyObject *_wrap_mapObj_maxsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31748 : PyObject *resultobj = 0;
31749 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31750 0 : void *argp1 = 0 ;
31751 : int res1 = 0 ;
31752 0 : PyObject * obj0 = 0 ;
31753 : int result;
31754 :
31755 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_maxsize_get",&obj0)) SWIG_fail;
31756 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31757 0 : if (!SWIG_IsOK(res1)) {
31758 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxsize_get" "', argument " "1"" of type '" "struct mapObj *""'");
31759 : }
31760 0 : arg1 = (struct mapObj *)(argp1);
31761 0 : result = (int) ((arg1)->maxsize);
31762 : resultobj = SWIG_From_int((int)(result));
31763 0 : return resultobj;
31764 0 : fail:
31765 : return NULL;
31766 : }
31767 :
31768 :
31769 1 : SWIGINTERN PyObject *_wrap_mapObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31770 : PyObject *resultobj = 0;
31771 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31772 1 : void *argp1 = 0 ;
31773 : int res1 = 0 ;
31774 1 : PyObject * obj0 = 0 ;
31775 : int result;
31776 :
31777 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_refcount_get",&obj0)) SWIG_fail;
31778 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31779 1 : if (!SWIG_IsOK(res1)) {
31780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_refcount_get" "', argument " "1"" of type '" "struct mapObj *""'");
31781 : }
31782 1 : arg1 = (struct mapObj *)(argp1);
31783 1 : result = (int) ((arg1)->refcount);
31784 : resultobj = SWIG_From_int((int)(result));
31785 1 : return resultobj;
31786 0 : fail:
31787 : return NULL;
31788 : }
31789 :
31790 :
31791 1 : SWIGINTERN PyObject *_wrap_mapObj_numlayers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31792 : PyObject *resultobj = 0;
31793 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31794 1 : void *argp1 = 0 ;
31795 : int res1 = 0 ;
31796 1 : PyObject * obj0 = 0 ;
31797 : int result;
31798 :
31799 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_numlayers_get",&obj0)) SWIG_fail;
31800 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31801 1 : if (!SWIG_IsOK(res1)) {
31802 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_numlayers_get" "', argument " "1"" of type '" "struct mapObj *""'");
31803 : }
31804 1 : arg1 = (struct mapObj *)(argp1);
31805 1 : result = (int) ((arg1)->numlayers);
31806 : resultobj = SWIG_From_int((int)(result));
31807 1 : return resultobj;
31808 0 : fail:
31809 : return NULL;
31810 : }
31811 :
31812 :
31813 0 : SWIGINTERN PyObject *_wrap_mapObj_maxlayers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31814 : PyObject *resultobj = 0;
31815 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31816 0 : void *argp1 = 0 ;
31817 : int res1 = 0 ;
31818 0 : PyObject * obj0 = 0 ;
31819 : int result;
31820 :
31821 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_maxlayers_get",&obj0)) SWIG_fail;
31822 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31823 0 : if (!SWIG_IsOK(res1)) {
31824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_maxlayers_get" "', argument " "1"" of type '" "struct mapObj *""'");
31825 : }
31826 0 : arg1 = (struct mapObj *)(argp1);
31827 0 : result = (int) ((arg1)->maxlayers);
31828 : resultobj = SWIG_From_int((int)(result));
31829 0 : return resultobj;
31830 0 : fail:
31831 : return NULL;
31832 : }
31833 :
31834 :
31835 1 : SWIGINTERN PyObject *_wrap_mapObj_symbolset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31836 : PyObject *resultobj = 0;
31837 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31838 1 : void *argp1 = 0 ;
31839 : int res1 = 0 ;
31840 1 : PyObject * obj0 = 0 ;
31841 : symbolSetObj *result = 0 ;
31842 :
31843 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_symbolset_get",&obj0)) SWIG_fail;
31844 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31845 1 : if (!SWIG_IsOK(res1)) {
31846 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_symbolset_get" "', argument " "1"" of type '" "struct mapObj *""'");
31847 : }
31848 1 : arg1 = (struct mapObj *)(argp1);
31849 1 : result = (symbolSetObj *)& ((arg1)->symbolset);
31850 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolSetObj, 0 | 0 );
31851 1 : return resultobj;
31852 0 : fail:
31853 : return NULL;
31854 : }
31855 :
31856 :
31857 1 : SWIGINTERN PyObject *_wrap_mapObj_fontset_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31858 : PyObject *resultobj = 0;
31859 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31860 1 : void *argp1 = 0 ;
31861 : int res1 = 0 ;
31862 1 : PyObject * obj0 = 0 ;
31863 : fontSetObj *result = 0 ;
31864 :
31865 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_fontset_get",&obj0)) SWIG_fail;
31866 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31867 1 : if (!SWIG_IsOK(res1)) {
31868 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_fontset_get" "', argument " "1"" of type '" "struct mapObj *""'");
31869 : }
31870 1 : arg1 = (struct mapObj *)(argp1);
31871 1 : result = (fontSetObj *)& ((arg1)->fontset);
31872 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_fontSetObj, 0 | 0 );
31873 1 : return resultobj;
31874 0 : fail:
31875 : return NULL;
31876 : }
31877 :
31878 :
31879 1 : SWIGINTERN PyObject *_wrap_mapObj_labelcache_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31880 : PyObject *resultobj = 0;
31881 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31882 1 : void *argp1 = 0 ;
31883 : int res1 = 0 ;
31884 1 : PyObject * obj0 = 0 ;
31885 : labelCacheObj *result = 0 ;
31886 :
31887 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_labelcache_get",&obj0)) SWIG_fail;
31888 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31889 1 : if (!SWIG_IsOK(res1)) {
31890 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_labelcache_get" "', argument " "1"" of type '" "struct mapObj *""'");
31891 : }
31892 1 : arg1 = (struct mapObj *)(argp1);
31893 1 : result = (labelCacheObj *)& ((arg1)->labelcache);
31894 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_labelCacheObj, 0 | 0 );
31895 1 : return resultobj;
31896 0 : fail:
31897 : return NULL;
31898 : }
31899 :
31900 :
31901 0 : SWIGINTERN PyObject *_wrap_mapObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31902 : PyObject *resultobj = 0;
31903 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31904 : int arg2 ;
31905 0 : void *argp1 = 0 ;
31906 : int res1 = 0 ;
31907 : int val2 ;
31908 : int ecode2 = 0 ;
31909 0 : PyObject * obj0 = 0 ;
31910 0 : PyObject * obj1 = 0 ;
31911 :
31912 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_transparent_set",&obj0,&obj1)) SWIG_fail;
31913 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31914 0 : if (!SWIG_IsOK(res1)) {
31915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_transparent_set" "', argument " "1"" of type '" "struct mapObj *""'");
31916 : }
31917 0 : arg1 = (struct mapObj *)(argp1);
31918 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31919 0 : if (!SWIG_IsOK(ecode2)) {
31920 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_transparent_set" "', argument " "2"" of type '" "int""'");
31921 : }
31922 : arg2 = (int)(val2);
31923 0 : if (arg1) (arg1)->transparent = arg2;
31924 : resultobj = SWIG_Py_Void();
31925 0 : return resultobj;
31926 0 : fail:
31927 : return NULL;
31928 : }
31929 :
31930 :
31931 0 : SWIGINTERN PyObject *_wrap_mapObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31932 : PyObject *resultobj = 0;
31933 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31934 0 : void *argp1 = 0 ;
31935 : int res1 = 0 ;
31936 0 : PyObject * obj0 = 0 ;
31937 : int result;
31938 :
31939 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_transparent_get",&obj0)) SWIG_fail;
31940 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31941 0 : if (!SWIG_IsOK(res1)) {
31942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_transparent_get" "', argument " "1"" of type '" "struct mapObj *""'");
31943 : }
31944 0 : arg1 = (struct mapObj *)(argp1);
31945 0 : result = (int) ((arg1)->transparent);
31946 : resultobj = SWIG_From_int((int)(result));
31947 0 : return resultobj;
31948 0 : fail:
31949 : return NULL;
31950 : }
31951 :
31952 :
31953 0 : SWIGINTERN PyObject *_wrap_mapObj_interlace_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31954 : PyObject *resultobj = 0;
31955 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31956 : int arg2 ;
31957 0 : void *argp1 = 0 ;
31958 : int res1 = 0 ;
31959 : int val2 ;
31960 : int ecode2 = 0 ;
31961 0 : PyObject * obj0 = 0 ;
31962 0 : PyObject * obj1 = 0 ;
31963 :
31964 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_interlace_set",&obj0,&obj1)) SWIG_fail;
31965 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31966 0 : if (!SWIG_IsOK(res1)) {
31967 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_interlace_set" "', argument " "1"" of type '" "struct mapObj *""'");
31968 : }
31969 0 : arg1 = (struct mapObj *)(argp1);
31970 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31971 0 : if (!SWIG_IsOK(ecode2)) {
31972 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_interlace_set" "', argument " "2"" of type '" "int""'");
31973 : }
31974 : arg2 = (int)(val2);
31975 0 : if (arg1) (arg1)->interlace = arg2;
31976 : resultobj = SWIG_Py_Void();
31977 0 : return resultobj;
31978 0 : fail:
31979 : return NULL;
31980 : }
31981 :
31982 :
31983 0 : SWIGINTERN PyObject *_wrap_mapObj_interlace_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31984 : PyObject *resultobj = 0;
31985 : struct mapObj *arg1 = (struct mapObj *) 0 ;
31986 0 : void *argp1 = 0 ;
31987 : int res1 = 0 ;
31988 0 : PyObject * obj0 = 0 ;
31989 : int result;
31990 :
31991 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_interlace_get",&obj0)) SWIG_fail;
31992 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
31993 0 : if (!SWIG_IsOK(res1)) {
31994 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_interlace_get" "', argument " "1"" of type '" "struct mapObj *""'");
31995 : }
31996 0 : arg1 = (struct mapObj *)(argp1);
31997 0 : result = (int) ((arg1)->interlace);
31998 : resultobj = SWIG_From_int((int)(result));
31999 0 : return resultobj;
32000 0 : fail:
32001 : return NULL;
32002 : }
32003 :
32004 :
32005 0 : SWIGINTERN PyObject *_wrap_mapObj_imagequality_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32006 : PyObject *resultobj = 0;
32007 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32008 : int arg2 ;
32009 0 : void *argp1 = 0 ;
32010 : int res1 = 0 ;
32011 : int val2 ;
32012 : int ecode2 = 0 ;
32013 0 : PyObject * obj0 = 0 ;
32014 0 : PyObject * obj1 = 0 ;
32015 :
32016 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_imagequality_set",&obj0,&obj1)) SWIG_fail;
32017 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32018 0 : if (!SWIG_IsOK(res1)) {
32019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagequality_set" "', argument " "1"" of type '" "struct mapObj *""'");
32020 : }
32021 0 : arg1 = (struct mapObj *)(argp1);
32022 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
32023 0 : if (!SWIG_IsOK(ecode2)) {
32024 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_imagequality_set" "', argument " "2"" of type '" "int""'");
32025 : }
32026 : arg2 = (int)(val2);
32027 0 : if (arg1) (arg1)->imagequality = arg2;
32028 : resultobj = SWIG_Py_Void();
32029 0 : return resultobj;
32030 0 : fail:
32031 : return NULL;
32032 : }
32033 :
32034 :
32035 0 : SWIGINTERN PyObject *_wrap_mapObj_imagequality_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32036 : PyObject *resultobj = 0;
32037 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32038 0 : void *argp1 = 0 ;
32039 : int res1 = 0 ;
32040 0 : PyObject * obj0 = 0 ;
32041 : int result;
32042 :
32043 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagequality_get",&obj0)) SWIG_fail;
32044 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32045 0 : if (!SWIG_IsOK(res1)) {
32046 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagequality_get" "', argument " "1"" of type '" "struct mapObj *""'");
32047 : }
32048 0 : arg1 = (struct mapObj *)(argp1);
32049 0 : result = (int) ((arg1)->imagequality);
32050 : resultobj = SWIG_From_int((int)(result));
32051 0 : return resultobj;
32052 0 : fail:
32053 : return NULL;
32054 : }
32055 :
32056 :
32057 1 : SWIGINTERN PyObject *_wrap_mapObj_extent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 : PyObject *resultobj = 0;
32059 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32060 : rectObj *arg2 = (rectObj *) 0 ;
32061 1 : void *argp1 = 0 ;
32062 : int res1 = 0 ;
32063 1 : void *argp2 = 0 ;
32064 : int res2 = 0 ;
32065 1 : PyObject * obj0 = 0 ;
32066 1 : PyObject * obj1 = 0 ;
32067 :
32068 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_extent_set",&obj0,&obj1)) SWIG_fail;
32069 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32070 1 : if (!SWIG_IsOK(res1)) {
32071 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_extent_set" "', argument " "1"" of type '" "struct mapObj *""'");
32072 : }
32073 1 : arg1 = (struct mapObj *)(argp1);
32074 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 | 0 );
32075 1 : if (!SWIG_IsOK(res2)) {
32076 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_extent_set" "', argument " "2"" of type '" "rectObj *""'");
32077 : }
32078 1 : arg2 = (rectObj *)(argp2);
32079 1 : if (arg1) (arg1)->extent = *arg2;
32080 : resultobj = SWIG_Py_Void();
32081 1 : return resultobj;
32082 0 : fail:
32083 : return NULL;
32084 : }
32085 :
32086 :
32087 1 : SWIGINTERN PyObject *_wrap_mapObj_extent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32088 : PyObject *resultobj = 0;
32089 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32090 1 : void *argp1 = 0 ;
32091 : int res1 = 0 ;
32092 1 : PyObject * obj0 = 0 ;
32093 : rectObj *result = 0 ;
32094 :
32095 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_extent_get",&obj0)) SWIG_fail;
32096 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32097 1 : if (!SWIG_IsOK(res1)) {
32098 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_extent_get" "', argument " "1"" of type '" "struct mapObj *""'");
32099 : }
32100 1 : arg1 = (struct mapObj *)(argp1);
32101 1 : result = (rectObj *)& ((arg1)->extent);
32102 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
32103 1 : return resultobj;
32104 0 : fail:
32105 : return NULL;
32106 : }
32107 :
32108 :
32109 0 : SWIGINTERN PyObject *_wrap_mapObj_cellsize_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32110 : PyObject *resultobj = 0;
32111 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32112 : double arg2 ;
32113 0 : void *argp1 = 0 ;
32114 : int res1 = 0 ;
32115 : double val2 ;
32116 : int ecode2 = 0 ;
32117 0 : PyObject * obj0 = 0 ;
32118 0 : PyObject * obj1 = 0 ;
32119 :
32120 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_cellsize_set",&obj0,&obj1)) SWIG_fail;
32121 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32122 0 : if (!SWIG_IsOK(res1)) {
32123 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_cellsize_set" "', argument " "1"" of type '" "struct mapObj *""'");
32124 : }
32125 0 : arg1 = (struct mapObj *)(argp1);
32126 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
32127 0 : if (!SWIG_IsOK(ecode2)) {
32128 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_cellsize_set" "', argument " "2"" of type '" "double""'");
32129 : }
32130 0 : arg2 = (double)(val2);
32131 0 : if (arg1) (arg1)->cellsize = arg2;
32132 : resultobj = SWIG_Py_Void();
32133 0 : return resultobj;
32134 0 : fail:
32135 : return NULL;
32136 : }
32137 :
32138 :
32139 0 : SWIGINTERN PyObject *_wrap_mapObj_cellsize_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32140 : PyObject *resultobj = 0;
32141 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32142 0 : void *argp1 = 0 ;
32143 : int res1 = 0 ;
32144 0 : PyObject * obj0 = 0 ;
32145 : double result;
32146 :
32147 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_cellsize_get",&obj0)) SWIG_fail;
32148 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32149 0 : if (!SWIG_IsOK(res1)) {
32150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_cellsize_get" "', argument " "1"" of type '" "struct mapObj *""'");
32151 : }
32152 0 : arg1 = (struct mapObj *)(argp1);
32153 0 : result = (double) ((arg1)->cellsize);
32154 0 : resultobj = SWIG_From_double((double)(result));
32155 0 : return resultobj;
32156 0 : fail:
32157 : return NULL;
32158 : }
32159 :
32160 :
32161 0 : SWIGINTERN PyObject *_wrap_mapObj_units_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32162 : PyObject *resultobj = 0;
32163 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32164 : enum MS_UNITS arg2 ;
32165 0 : void *argp1 = 0 ;
32166 : int res1 = 0 ;
32167 : int val2 ;
32168 : int ecode2 = 0 ;
32169 0 : PyObject * obj0 = 0 ;
32170 0 : PyObject * obj1 = 0 ;
32171 :
32172 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_units_set",&obj0,&obj1)) SWIG_fail;
32173 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32174 0 : if (!SWIG_IsOK(res1)) {
32175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_units_set" "', argument " "1"" of type '" "struct mapObj *""'");
32176 : }
32177 0 : arg1 = (struct mapObj *)(argp1);
32178 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
32179 0 : if (!SWIG_IsOK(ecode2)) {
32180 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_units_set" "', argument " "2"" of type '" "enum MS_UNITS""'");
32181 : }
32182 : arg2 = (enum MS_UNITS)(val2);
32183 0 : if (arg1) (arg1)->units = arg2;
32184 : resultobj = SWIG_Py_Void();
32185 0 : return resultobj;
32186 0 : fail:
32187 : return NULL;
32188 : }
32189 :
32190 :
32191 0 : SWIGINTERN PyObject *_wrap_mapObj_units_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32192 : PyObject *resultobj = 0;
32193 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32194 0 : void *argp1 = 0 ;
32195 : int res1 = 0 ;
32196 0 : PyObject * obj0 = 0 ;
32197 : enum MS_UNITS result;
32198 :
32199 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_units_get",&obj0)) SWIG_fail;
32200 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32201 0 : if (!SWIG_IsOK(res1)) {
32202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_units_get" "', argument " "1"" of type '" "struct mapObj *""'");
32203 : }
32204 0 : arg1 = (struct mapObj *)(argp1);
32205 0 : result = (enum MS_UNITS) ((arg1)->units);
32206 : resultobj = SWIG_From_int((int)(result));
32207 0 : return resultobj;
32208 0 : fail:
32209 : return NULL;
32210 : }
32211 :
32212 :
32213 0 : SWIGINTERN PyObject *_wrap_mapObj_scaledenom_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32214 : PyObject *resultobj = 0;
32215 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32216 : double arg2 ;
32217 0 : void *argp1 = 0 ;
32218 : int res1 = 0 ;
32219 : double val2 ;
32220 : int ecode2 = 0 ;
32221 0 : PyObject * obj0 = 0 ;
32222 0 : PyObject * obj1 = 0 ;
32223 :
32224 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_scaledenom_set",&obj0,&obj1)) SWIG_fail;
32225 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32226 0 : if (!SWIG_IsOK(res1)) {
32227 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaledenom_set" "', argument " "1"" of type '" "struct mapObj *""'");
32228 : }
32229 0 : arg1 = (struct mapObj *)(argp1);
32230 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
32231 0 : if (!SWIG_IsOK(ecode2)) {
32232 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_scaledenom_set" "', argument " "2"" of type '" "double""'");
32233 : }
32234 0 : arg2 = (double)(val2);
32235 0 : if (arg1) (arg1)->scaledenom = arg2;
32236 : resultobj = SWIG_Py_Void();
32237 0 : return resultobj;
32238 0 : fail:
32239 : return NULL;
32240 : }
32241 :
32242 :
32243 1 : SWIGINTERN PyObject *_wrap_mapObj_scaledenom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32244 : PyObject *resultobj = 0;
32245 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32246 1 : void *argp1 = 0 ;
32247 : int res1 = 0 ;
32248 1 : PyObject * obj0 = 0 ;
32249 : double result;
32250 :
32251 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_scaledenom_get",&obj0)) SWIG_fail;
32252 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32253 1 : if (!SWIG_IsOK(res1)) {
32254 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaledenom_get" "', argument " "1"" of type '" "struct mapObj *""'");
32255 : }
32256 1 : arg1 = (struct mapObj *)(argp1);
32257 1 : result = (double) ((arg1)->scaledenom);
32258 1 : resultobj = SWIG_From_double((double)(result));
32259 1 : return resultobj;
32260 0 : fail:
32261 : return NULL;
32262 : }
32263 :
32264 :
32265 0 : SWIGINTERN PyObject *_wrap_mapObj_resolution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32266 : PyObject *resultobj = 0;
32267 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32268 : double arg2 ;
32269 0 : void *argp1 = 0 ;
32270 : int res1 = 0 ;
32271 : double val2 ;
32272 : int ecode2 = 0 ;
32273 0 : PyObject * obj0 = 0 ;
32274 0 : PyObject * obj1 = 0 ;
32275 :
32276 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_resolution_set",&obj0,&obj1)) SWIG_fail;
32277 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32278 0 : if (!SWIG_IsOK(res1)) {
32279 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_resolution_set" "', argument " "1"" of type '" "struct mapObj *""'");
32280 : }
32281 0 : arg1 = (struct mapObj *)(argp1);
32282 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
32283 0 : if (!SWIG_IsOK(ecode2)) {
32284 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_resolution_set" "', argument " "2"" of type '" "double""'");
32285 : }
32286 0 : arg2 = (double)(val2);
32287 0 : if (arg1) (arg1)->resolution = arg2;
32288 : resultobj = SWIG_Py_Void();
32289 0 : return resultobj;
32290 0 : fail:
32291 : return NULL;
32292 : }
32293 :
32294 :
32295 0 : SWIGINTERN PyObject *_wrap_mapObj_resolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32296 : PyObject *resultobj = 0;
32297 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32298 0 : void *argp1 = 0 ;
32299 : int res1 = 0 ;
32300 0 : PyObject * obj0 = 0 ;
32301 : double result;
32302 :
32303 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_resolution_get",&obj0)) SWIG_fail;
32304 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32305 0 : if (!SWIG_IsOK(res1)) {
32306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_resolution_get" "', argument " "1"" of type '" "struct mapObj *""'");
32307 : }
32308 0 : arg1 = (struct mapObj *)(argp1);
32309 0 : result = (double) ((arg1)->resolution);
32310 0 : resultobj = SWIG_From_double((double)(result));
32311 0 : return resultobj;
32312 0 : fail:
32313 : return NULL;
32314 : }
32315 :
32316 :
32317 0 : SWIGINTERN PyObject *_wrap_mapObj_defresolution_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32318 : PyObject *resultobj = 0;
32319 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32320 : double arg2 ;
32321 0 : void *argp1 = 0 ;
32322 : int res1 = 0 ;
32323 : double val2 ;
32324 : int ecode2 = 0 ;
32325 0 : PyObject * obj0 = 0 ;
32326 0 : PyObject * obj1 = 0 ;
32327 :
32328 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_defresolution_set",&obj0,&obj1)) SWIG_fail;
32329 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32330 0 : if (!SWIG_IsOK(res1)) {
32331 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_defresolution_set" "', argument " "1"" of type '" "struct mapObj *""'");
32332 : }
32333 0 : arg1 = (struct mapObj *)(argp1);
32334 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
32335 0 : if (!SWIG_IsOK(ecode2)) {
32336 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_defresolution_set" "', argument " "2"" of type '" "double""'");
32337 : }
32338 0 : arg2 = (double)(val2);
32339 0 : if (arg1) (arg1)->defresolution = arg2;
32340 : resultobj = SWIG_Py_Void();
32341 0 : return resultobj;
32342 0 : fail:
32343 : return NULL;
32344 : }
32345 :
32346 :
32347 0 : SWIGINTERN PyObject *_wrap_mapObj_defresolution_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32348 : PyObject *resultobj = 0;
32349 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32350 0 : void *argp1 = 0 ;
32351 : int res1 = 0 ;
32352 0 : PyObject * obj0 = 0 ;
32353 : double result;
32354 :
32355 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_defresolution_get",&obj0)) SWIG_fail;
32356 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32357 0 : if (!SWIG_IsOK(res1)) {
32358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_defresolution_get" "', argument " "1"" of type '" "struct mapObj *""'");
32359 : }
32360 0 : arg1 = (struct mapObj *)(argp1);
32361 0 : result = (double) ((arg1)->defresolution);
32362 0 : resultobj = SWIG_From_double((double)(result));
32363 0 : return resultobj;
32364 0 : fail:
32365 : return NULL;
32366 : }
32367 :
32368 :
32369 0 : SWIGINTERN PyObject *_wrap_mapObj_shapepath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32370 : PyObject *resultobj = 0;
32371 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32372 : char *arg2 = (char *) 0 ;
32373 0 : void *argp1 = 0 ;
32374 : int res1 = 0 ;
32375 : int res2 ;
32376 0 : char *buf2 = 0 ;
32377 0 : int alloc2 = 0 ;
32378 0 : PyObject * obj0 = 0 ;
32379 0 : PyObject * obj1 = 0 ;
32380 :
32381 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_shapepath_set",&obj0,&obj1)) SWIG_fail;
32382 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32383 0 : if (!SWIG_IsOK(res1)) {
32384 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_shapepath_set" "', argument " "1"" of type '" "struct mapObj *""'");
32385 : }
32386 0 : arg1 = (struct mapObj *)(argp1);
32387 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32388 0 : if (!SWIG_IsOK(res2)) {
32389 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_shapepath_set" "', argument " "2"" of type '" "char *""'");
32390 : }
32391 0 : arg2 = (char *)(buf2);
32392 : {
32393 0 : if (arg1->shapepath) free((char*)arg1->shapepath);
32394 0 : if (arg2) {
32395 0 : arg1->shapepath = (char *) malloc(strlen(arg2)+1);
32396 : strcpy((char*)arg1->shapepath,arg2);
32397 : } else {
32398 0 : arg1->shapepath = 0;
32399 : }
32400 : }
32401 : resultobj = SWIG_Py_Void();
32402 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32403 : return resultobj;
32404 0 : fail:
32405 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32406 : return NULL;
32407 : }
32408 :
32409 :
32410 0 : SWIGINTERN PyObject *_wrap_mapObj_shapepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32411 : PyObject *resultobj = 0;
32412 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32413 0 : void *argp1 = 0 ;
32414 : int res1 = 0 ;
32415 0 : PyObject * obj0 = 0 ;
32416 : char *result = 0 ;
32417 :
32418 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_shapepath_get",&obj0)) SWIG_fail;
32419 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32420 0 : if (!SWIG_IsOK(res1)) {
32421 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_shapepath_get" "', argument " "1"" of type '" "struct mapObj *""'");
32422 : }
32423 0 : arg1 = (struct mapObj *)(argp1);
32424 0 : result = (char *) ((arg1)->shapepath);
32425 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32426 0 : return resultobj;
32427 0 : fail:
32428 : return NULL;
32429 : }
32430 :
32431 :
32432 0 : SWIGINTERN PyObject *_wrap_mapObj_mappath_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32433 : PyObject *resultobj = 0;
32434 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32435 : char *arg2 = (char *) 0 ;
32436 0 : void *argp1 = 0 ;
32437 : int res1 = 0 ;
32438 : int res2 ;
32439 0 : char *buf2 = 0 ;
32440 0 : int alloc2 = 0 ;
32441 0 : PyObject * obj0 = 0 ;
32442 0 : PyObject * obj1 = 0 ;
32443 :
32444 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_mappath_set",&obj0,&obj1)) SWIG_fail;
32445 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32446 0 : if (!SWIG_IsOK(res1)) {
32447 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_mappath_set" "', argument " "1"" of type '" "struct mapObj *""'");
32448 : }
32449 0 : arg1 = (struct mapObj *)(argp1);
32450 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32451 0 : if (!SWIG_IsOK(res2)) {
32452 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_mappath_set" "', argument " "2"" of type '" "char *""'");
32453 : }
32454 0 : arg2 = (char *)(buf2);
32455 : {
32456 0 : if (arg1->mappath) free((char*)arg1->mappath);
32457 0 : if (arg2) {
32458 0 : arg1->mappath = (char *) malloc(strlen(arg2)+1);
32459 : strcpy((char*)arg1->mappath,arg2);
32460 : } else {
32461 0 : arg1->mappath = 0;
32462 : }
32463 : }
32464 : resultobj = SWIG_Py_Void();
32465 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32466 : return resultobj;
32467 0 : fail:
32468 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32469 : return NULL;
32470 : }
32471 :
32472 :
32473 0 : SWIGINTERN PyObject *_wrap_mapObj_mappath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32474 : PyObject *resultobj = 0;
32475 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32476 0 : void *argp1 = 0 ;
32477 : int res1 = 0 ;
32478 0 : PyObject * obj0 = 0 ;
32479 : char *result = 0 ;
32480 :
32481 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_mappath_get",&obj0)) SWIG_fail;
32482 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32483 0 : if (!SWIG_IsOK(res1)) {
32484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_mappath_get" "', argument " "1"" of type '" "struct mapObj *""'");
32485 : }
32486 0 : arg1 = (struct mapObj *)(argp1);
32487 0 : result = (char *) ((arg1)->mappath);
32488 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32489 0 : return resultobj;
32490 0 : fail:
32491 : return NULL;
32492 : }
32493 :
32494 :
32495 0 : SWIGINTERN PyObject *_wrap_mapObj_sldurl_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32496 : PyObject *resultobj = 0;
32497 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32498 : char *arg2 = (char *) 0 ;
32499 0 : void *argp1 = 0 ;
32500 : int res1 = 0 ;
32501 : int res2 ;
32502 0 : char *buf2 = 0 ;
32503 0 : int alloc2 = 0 ;
32504 0 : PyObject * obj0 = 0 ;
32505 0 : PyObject * obj1 = 0 ;
32506 :
32507 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_sldurl_set",&obj0,&obj1)) SWIG_fail;
32508 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32509 0 : if (!SWIG_IsOK(res1)) {
32510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_sldurl_set" "', argument " "1"" of type '" "struct mapObj *""'");
32511 : }
32512 0 : arg1 = (struct mapObj *)(argp1);
32513 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32514 0 : if (!SWIG_IsOK(res2)) {
32515 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_sldurl_set" "', argument " "2"" of type '" "char *""'");
32516 : }
32517 0 : arg2 = (char *)(buf2);
32518 : {
32519 0 : if (arg1->sldurl) free((char*)arg1->sldurl);
32520 0 : if (arg2) {
32521 0 : arg1->sldurl = (char *) malloc(strlen(arg2)+1);
32522 : strcpy((char*)arg1->sldurl,arg2);
32523 : } else {
32524 0 : arg1->sldurl = 0;
32525 : }
32526 : }
32527 : resultobj = SWIG_Py_Void();
32528 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32529 : return resultobj;
32530 0 : fail:
32531 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32532 : return NULL;
32533 : }
32534 :
32535 :
32536 0 : SWIGINTERN PyObject *_wrap_mapObj_sldurl_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32537 : PyObject *resultobj = 0;
32538 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32539 0 : void *argp1 = 0 ;
32540 : int res1 = 0 ;
32541 0 : PyObject * obj0 = 0 ;
32542 : char *result = 0 ;
32543 :
32544 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_sldurl_get",&obj0)) SWIG_fail;
32545 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32546 0 : if (!SWIG_IsOK(res1)) {
32547 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_sldurl_get" "', argument " "1"" of type '" "struct mapObj *""'");
32548 : }
32549 0 : arg1 = (struct mapObj *)(argp1);
32550 0 : result = (char *) ((arg1)->sldurl);
32551 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32552 0 : return resultobj;
32553 0 : fail:
32554 : return NULL;
32555 : }
32556 :
32557 :
32558 0 : SWIGINTERN PyObject *_wrap_mapObj_imagecolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32559 : PyObject *resultobj = 0;
32560 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32561 : colorObj *arg2 = (colorObj *) 0 ;
32562 0 : void *argp1 = 0 ;
32563 : int res1 = 0 ;
32564 0 : void *argp2 = 0 ;
32565 : int res2 = 0 ;
32566 0 : PyObject * obj0 = 0 ;
32567 0 : PyObject * obj1 = 0 ;
32568 :
32569 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_imagecolor_set",&obj0,&obj1)) SWIG_fail;
32570 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32571 0 : if (!SWIG_IsOK(res1)) {
32572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagecolor_set" "', argument " "1"" of type '" "struct mapObj *""'");
32573 : }
32574 0 : arg1 = (struct mapObj *)(argp1);
32575 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_colorObj, 0 | 0 );
32576 0 : if (!SWIG_IsOK(res2)) {
32577 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_imagecolor_set" "', argument " "2"" of type '" "colorObj *""'");
32578 : }
32579 0 : arg2 = (colorObj *)(argp2);
32580 0 : if (arg1) (arg1)->imagecolor = *arg2;
32581 : resultobj = SWIG_Py_Void();
32582 0 : return resultobj;
32583 0 : fail:
32584 : return NULL;
32585 : }
32586 :
32587 :
32588 0 : SWIGINTERN PyObject *_wrap_mapObj_imagecolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32589 : PyObject *resultobj = 0;
32590 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32591 0 : void *argp1 = 0 ;
32592 : int res1 = 0 ;
32593 0 : PyObject * obj0 = 0 ;
32594 : colorObj *result = 0 ;
32595 :
32596 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagecolor_get",&obj0)) SWIG_fail;
32597 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32598 0 : if (!SWIG_IsOK(res1)) {
32599 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagecolor_get" "', argument " "1"" of type '" "struct mapObj *""'");
32600 : }
32601 0 : arg1 = (struct mapObj *)(argp1);
32602 0 : result = (colorObj *)& ((arg1)->imagecolor);
32603 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, 0 | 0 );
32604 0 : return resultobj;
32605 0 : fail:
32606 : return NULL;
32607 : }
32608 :
32609 :
32610 1 : SWIGINTERN PyObject *_wrap_mapObj_numoutputformats_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32611 : PyObject *resultobj = 0;
32612 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32613 1 : void *argp1 = 0 ;
32614 : int res1 = 0 ;
32615 1 : PyObject * obj0 = 0 ;
32616 : int result;
32617 :
32618 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_numoutputformats_get",&obj0)) SWIG_fail;
32619 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32620 1 : if (!SWIG_IsOK(res1)) {
32621 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_numoutputformats_get" "', argument " "1"" of type '" "struct mapObj *""'");
32622 : }
32623 1 : arg1 = (struct mapObj *)(argp1);
32624 1 : result = (int) ((arg1)->numoutputformats);
32625 : resultobj = SWIG_From_int((int)(result));
32626 1 : return resultobj;
32627 0 : fail:
32628 : return NULL;
32629 : }
32630 :
32631 :
32632 1 : SWIGINTERN PyObject *_wrap_mapObj_outputformat_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32633 : PyObject *resultobj = 0;
32634 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32635 1 : void *argp1 = 0 ;
32636 : int res1 = 0 ;
32637 1 : PyObject * obj0 = 0 ;
32638 : outputFormatObj *result = 0 ;
32639 :
32640 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_outputformat_get",&obj0)) SWIG_fail;
32641 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32642 1 : if (!SWIG_IsOK(res1)) {
32643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_outputformat_get" "', argument " "1"" of type '" "struct mapObj *""'");
32644 : }
32645 1 : arg1 = (struct mapObj *)(argp1);
32646 1 : result = (outputFormatObj *) ((arg1)->outputformat);
32647 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 | 0 );
32648 1 : return resultobj;
32649 0 : fail:
32650 : return NULL;
32651 : }
32652 :
32653 :
32654 0 : SWIGINTERN PyObject *_wrap_mapObj_imagetype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32655 : PyObject *resultobj = 0;
32656 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32657 0 : void *argp1 = 0 ;
32658 : int res1 = 0 ;
32659 0 : PyObject * obj0 = 0 ;
32660 : char *result = 0 ;
32661 :
32662 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_imagetype_get",&obj0)) SWIG_fail;
32663 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32664 0 : if (!SWIG_IsOK(res1)) {
32665 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_imagetype_get" "', argument " "1"" of type '" "struct mapObj *""'");
32666 : }
32667 0 : arg1 = (struct mapObj *)(argp1);
32668 0 : result = (char *) ((arg1)->imagetype);
32669 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32670 0 : return resultobj;
32671 0 : fail:
32672 : return NULL;
32673 : }
32674 :
32675 :
32676 0 : SWIGINTERN PyObject *_wrap_mapObj_reference_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32677 : PyObject *resultobj = 0;
32678 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32679 0 : void *argp1 = 0 ;
32680 : int res1 = 0 ;
32681 0 : PyObject * obj0 = 0 ;
32682 : referenceMapObj *result = 0 ;
32683 :
32684 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_reference_get",&obj0)) SWIG_fail;
32685 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32686 0 : if (!SWIG_IsOK(res1)) {
32687 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_reference_get" "', argument " "1"" of type '" "struct mapObj *""'");
32688 : }
32689 0 : arg1 = (struct mapObj *)(argp1);
32690 0 : result = (referenceMapObj *)& ((arg1)->reference);
32691 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_referenceMapObj, 0 | 0 );
32692 0 : return resultobj;
32693 0 : fail:
32694 : return NULL;
32695 : }
32696 :
32697 :
32698 0 : SWIGINTERN PyObject *_wrap_mapObj_scalebar_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32699 : PyObject *resultobj = 0;
32700 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32701 0 : void *argp1 = 0 ;
32702 : int res1 = 0 ;
32703 0 : PyObject * obj0 = 0 ;
32704 : scalebarObj *result = 0 ;
32705 :
32706 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_scalebar_get",&obj0)) SWIG_fail;
32707 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32708 0 : if (!SWIG_IsOK(res1)) {
32709 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scalebar_get" "', argument " "1"" of type '" "struct mapObj *""'");
32710 : }
32711 0 : arg1 = (struct mapObj *)(argp1);
32712 0 : result = (scalebarObj *)& ((arg1)->scalebar);
32713 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_scalebarObj, 0 | 0 );
32714 0 : return resultobj;
32715 0 : fail:
32716 : return NULL;
32717 : }
32718 :
32719 :
32720 0 : SWIGINTERN PyObject *_wrap_mapObj_legend_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32721 : PyObject *resultobj = 0;
32722 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32723 0 : void *argp1 = 0 ;
32724 : int res1 = 0 ;
32725 0 : PyObject * obj0 = 0 ;
32726 : legendObj *result = 0 ;
32727 :
32728 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_legend_get",&obj0)) SWIG_fail;
32729 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32730 0 : if (!SWIG_IsOK(res1)) {
32731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_legend_get" "', argument " "1"" of type '" "struct mapObj *""'");
32732 : }
32733 0 : arg1 = (struct mapObj *)(argp1);
32734 0 : result = (legendObj *)& ((arg1)->legend);
32735 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_legendObj, 0 | 0 );
32736 0 : return resultobj;
32737 0 : fail:
32738 : return NULL;
32739 : }
32740 :
32741 :
32742 0 : SWIGINTERN PyObject *_wrap_mapObj_querymap_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 : PyObject *resultobj = 0;
32744 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32745 0 : void *argp1 = 0 ;
32746 : int res1 = 0 ;
32747 0 : PyObject * obj0 = 0 ;
32748 : queryMapObj *result = 0 ;
32749 :
32750 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_querymap_get",&obj0)) SWIG_fail;
32751 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32752 0 : if (!SWIG_IsOK(res1)) {
32753 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_querymap_get" "', argument " "1"" of type '" "struct mapObj *""'");
32754 : }
32755 0 : arg1 = (struct mapObj *)(argp1);
32756 0 : result = (queryMapObj *)& ((arg1)->querymap);
32757 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_queryMapObj, 0 | 0 );
32758 0 : return resultobj;
32759 0 : fail:
32760 : return NULL;
32761 : }
32762 :
32763 :
32764 1 : SWIGINTERN PyObject *_wrap_mapObj_web_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32765 : PyObject *resultobj = 0;
32766 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32767 1 : void *argp1 = 0 ;
32768 : int res1 = 0 ;
32769 1 : PyObject * obj0 = 0 ;
32770 : webObj *result = 0 ;
32771 :
32772 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_web_get",&obj0)) SWIG_fail;
32773 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32774 1 : if (!SWIG_IsOK(res1)) {
32775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_web_get" "', argument " "1"" of type '" "struct mapObj *""'");
32776 : }
32777 1 : arg1 = (struct mapObj *)(argp1);
32778 1 : result = (webObj *)& ((arg1)->web);
32779 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_webObj, 0 | 0 );
32780 1 : return resultobj;
32781 0 : fail:
32782 : return NULL;
32783 : }
32784 :
32785 :
32786 0 : SWIGINTERN PyObject *_wrap_mapObj_layerorder_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32787 : PyObject *resultobj = 0;
32788 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32789 : int *arg2 = (int *) 0 ;
32790 0 : void *argp1 = 0 ;
32791 : int res1 = 0 ;
32792 0 : void *argp2 = 0 ;
32793 : int res2 = 0 ;
32794 0 : PyObject * obj0 = 0 ;
32795 0 : PyObject * obj1 = 0 ;
32796 :
32797 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_layerorder_set",&obj0,&obj1)) SWIG_fail;
32798 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32799 0 : if (!SWIG_IsOK(res1)) {
32800 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_layerorder_set" "', argument " "1"" of type '" "struct mapObj *""'");
32801 : }
32802 0 : arg1 = (struct mapObj *)(argp1);
32803 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, SWIG_POINTER_DISOWN | 0 );
32804 0 : if (!SWIG_IsOK(res2)) {
32805 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_layerorder_set" "', argument " "2"" of type '" "int *""'");
32806 : }
32807 0 : arg2 = (int *)(argp2);
32808 0 : if (arg1) (arg1)->layerorder = arg2;
32809 : resultobj = SWIG_Py_Void();
32810 0 : return resultobj;
32811 0 : fail:
32812 : return NULL;
32813 : }
32814 :
32815 :
32816 0 : SWIGINTERN PyObject *_wrap_mapObj_layerorder_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32817 : PyObject *resultobj = 0;
32818 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32819 0 : void *argp1 = 0 ;
32820 : int res1 = 0 ;
32821 0 : PyObject * obj0 = 0 ;
32822 : int *result = 0 ;
32823 :
32824 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_layerorder_get",&obj0)) SWIG_fail;
32825 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32826 0 : if (!SWIG_IsOK(res1)) {
32827 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_layerorder_get" "', argument " "1"" of type '" "struct mapObj *""'");
32828 : }
32829 0 : arg1 = (struct mapObj *)(argp1);
32830 0 : result = (int *) ((arg1)->layerorder);
32831 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 | 0 );
32832 0 : return resultobj;
32833 0 : fail:
32834 : return NULL;
32835 : }
32836 :
32837 :
32838 1 : SWIGINTERN PyObject *_wrap_mapObj_debug_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32839 : PyObject *resultobj = 0;
32840 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32841 : int arg2 ;
32842 1 : void *argp1 = 0 ;
32843 : int res1 = 0 ;
32844 : int val2 ;
32845 : int ecode2 = 0 ;
32846 1 : PyObject * obj0 = 0 ;
32847 1 : PyObject * obj1 = 0 ;
32848 :
32849 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_debug_set",&obj0,&obj1)) SWIG_fail;
32850 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32851 1 : if (!SWIG_IsOK(res1)) {
32852 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_debug_set" "', argument " "1"" of type '" "struct mapObj *""'");
32853 : }
32854 1 : arg1 = (struct mapObj *)(argp1);
32855 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
32856 1 : if (!SWIG_IsOK(ecode2)) {
32857 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_debug_set" "', argument " "2"" of type '" "int""'");
32858 : }
32859 : arg2 = (int)(val2);
32860 1 : if (arg1) (arg1)->debug = arg2;
32861 : resultobj = SWIG_Py_Void();
32862 1 : return resultobj;
32863 0 : fail:
32864 : return NULL;
32865 : }
32866 :
32867 :
32868 0 : SWIGINTERN PyObject *_wrap_mapObj_debug_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32869 : PyObject *resultobj = 0;
32870 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32871 0 : void *argp1 = 0 ;
32872 : int res1 = 0 ;
32873 0 : PyObject * obj0 = 0 ;
32874 : int result;
32875 :
32876 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_debug_get",&obj0)) SWIG_fail;
32877 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32878 0 : if (!SWIG_IsOK(res1)) {
32879 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_debug_get" "', argument " "1"" of type '" "struct mapObj *""'");
32880 : }
32881 0 : arg1 = (struct mapObj *)(argp1);
32882 0 : result = (int) ((arg1)->debug);
32883 : resultobj = SWIG_From_int((int)(result));
32884 0 : return resultobj;
32885 0 : fail:
32886 : return NULL;
32887 : }
32888 :
32889 :
32890 0 : SWIGINTERN PyObject *_wrap_mapObj_datapattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32891 : PyObject *resultobj = 0;
32892 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32893 : char *arg2 = (char *) 0 ;
32894 0 : void *argp1 = 0 ;
32895 : int res1 = 0 ;
32896 : int res2 ;
32897 0 : char *buf2 = 0 ;
32898 0 : int alloc2 = 0 ;
32899 0 : PyObject * obj0 = 0 ;
32900 0 : PyObject * obj1 = 0 ;
32901 :
32902 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_datapattern_set",&obj0,&obj1)) SWIG_fail;
32903 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32904 0 : if (!SWIG_IsOK(res1)) {
32905 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_datapattern_set" "', argument " "1"" of type '" "struct mapObj *""'");
32906 : }
32907 0 : arg1 = (struct mapObj *)(argp1);
32908 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32909 0 : if (!SWIG_IsOK(res2)) {
32910 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_datapattern_set" "', argument " "2"" of type '" "char *""'");
32911 : }
32912 0 : arg2 = (char *)(buf2);
32913 : {
32914 0 : if (arg1->datapattern) free((char*)arg1->datapattern);
32915 0 : if (arg2) {
32916 0 : arg1->datapattern = (char *) malloc(strlen(arg2)+1);
32917 : strcpy((char*)arg1->datapattern,arg2);
32918 : } else {
32919 0 : arg1->datapattern = 0;
32920 : }
32921 : }
32922 : resultobj = SWIG_Py_Void();
32923 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32924 : return resultobj;
32925 0 : fail:
32926 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32927 : return NULL;
32928 : }
32929 :
32930 :
32931 0 : SWIGINTERN PyObject *_wrap_mapObj_datapattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32932 : PyObject *resultobj = 0;
32933 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32934 0 : void *argp1 = 0 ;
32935 : int res1 = 0 ;
32936 0 : PyObject * obj0 = 0 ;
32937 : char *result = 0 ;
32938 :
32939 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_datapattern_get",&obj0)) SWIG_fail;
32940 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32941 0 : if (!SWIG_IsOK(res1)) {
32942 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_datapattern_get" "', argument " "1"" of type '" "struct mapObj *""'");
32943 : }
32944 0 : arg1 = (struct mapObj *)(argp1);
32945 0 : result = (char *) ((arg1)->datapattern);
32946 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32947 0 : return resultobj;
32948 0 : fail:
32949 : return NULL;
32950 : }
32951 :
32952 :
32953 0 : SWIGINTERN PyObject *_wrap_mapObj_templatepattern_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32954 : PyObject *resultobj = 0;
32955 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32956 : char *arg2 = (char *) 0 ;
32957 0 : void *argp1 = 0 ;
32958 : int res1 = 0 ;
32959 : int res2 ;
32960 0 : char *buf2 = 0 ;
32961 0 : int alloc2 = 0 ;
32962 0 : PyObject * obj0 = 0 ;
32963 0 : PyObject * obj1 = 0 ;
32964 :
32965 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_templatepattern_set",&obj0,&obj1)) SWIG_fail;
32966 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
32967 0 : if (!SWIG_IsOK(res1)) {
32968 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_templatepattern_set" "', argument " "1"" of type '" "struct mapObj *""'");
32969 : }
32970 0 : arg1 = (struct mapObj *)(argp1);
32971 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32972 0 : if (!SWIG_IsOK(res2)) {
32973 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_templatepattern_set" "', argument " "2"" of type '" "char *""'");
32974 : }
32975 0 : arg2 = (char *)(buf2);
32976 : {
32977 0 : if (arg1->templatepattern) free((char*)arg1->templatepattern);
32978 0 : if (arg2) {
32979 0 : arg1->templatepattern = (char *) malloc(strlen(arg2)+1);
32980 : strcpy((char*)arg1->templatepattern,arg2);
32981 : } else {
32982 0 : arg1->templatepattern = 0;
32983 : }
32984 : }
32985 : resultobj = SWIG_Py_Void();
32986 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32987 : return resultobj;
32988 0 : fail:
32989 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32990 : return NULL;
32991 : }
32992 :
32993 :
32994 0 : SWIGINTERN PyObject *_wrap_mapObj_templatepattern_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32995 : PyObject *resultobj = 0;
32996 : struct mapObj *arg1 = (struct mapObj *) 0 ;
32997 0 : void *argp1 = 0 ;
32998 : int res1 = 0 ;
32999 0 : PyObject * obj0 = 0 ;
33000 : char *result = 0 ;
33001 :
33002 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_templatepattern_get",&obj0)) SWIG_fail;
33003 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33004 0 : if (!SWIG_IsOK(res1)) {
33005 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_templatepattern_get" "', argument " "1"" of type '" "struct mapObj *""'");
33006 : }
33007 0 : arg1 = (struct mapObj *)(argp1);
33008 0 : result = (char *) ((arg1)->templatepattern);
33009 0 : resultobj = SWIG_FromCharPtr((const char *)result);
33010 0 : return resultobj;
33011 0 : fail:
33012 : return NULL;
33013 : }
33014 :
33015 :
33016 0 : SWIGINTERN PyObject *_wrap_mapObj_configoptions_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33017 : PyObject *resultobj = 0;
33018 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33019 0 : void *argp1 = 0 ;
33020 : int res1 = 0 ;
33021 0 : PyObject * obj0 = 0 ;
33022 : hashTableObj *result = 0 ;
33023 :
33024 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_configoptions_get",&obj0)) SWIG_fail;
33025 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33026 0 : if (!SWIG_IsOK(res1)) {
33027 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_configoptions_get" "', argument " "1"" of type '" "struct mapObj *""'");
33028 : }
33029 0 : arg1 = (struct mapObj *)(argp1);
33030 0 : result = (hashTableObj *)& ((arg1)->configoptions);
33031 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, 0 | 0 );
33032 0 : return resultobj;
33033 0 : fail:
33034 : return NULL;
33035 : }
33036 :
33037 :
33038 1 : SWIGINTERN PyObject *_wrap_new_mapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33039 : PyObject *resultobj = 0;
33040 : char *arg1 = (char *) "" ;
33041 : int res1 ;
33042 1 : char *buf1 = 0 ;
33043 1 : int alloc1 = 0 ;
33044 1 : PyObject * obj0 = 0 ;
33045 : struct mapObj *result = 0 ;
33046 :
33047 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_mapObj",&obj0)) SWIG_fail;
33048 1 : if (obj0) {
33049 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
33050 1 : if (!SWIG_IsOK(res1)) {
33051 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_mapObj" "', argument " "1"" of type '" "char *""'");
33052 : }
33053 1 : arg1 = (char *)(buf1);
33054 : }
33055 : {
33056 1 : result = (struct mapObj *)new_mapObj(arg1); {
33057 1 : errorObj *ms_error = msGetErrorObj();
33058 :
33059 1 : switch(ms_error->code) {
33060 : case MS_NOERR:
33061 : break;
33062 0 : case MS_NOTFOUND:
33063 0 : msResetErrorList();
33064 0 : break;
33065 : case -1:
33066 : break;
33067 0 : case MS_IOERR:
33068 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33069 0 : _raise_ms_exception();
33070 0 : msResetErrorList();
33071 0 : return NULL;
33072 : }
33073 : default:
33074 0 : _raise_ms_exception();
33075 0 : msResetErrorList();
33076 0 : return NULL;
33077 : }
33078 :
33079 : }
33080 : }
33081 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_NEW | 0 );
33082 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
33083 : return resultobj;
33084 0 : fail:
33085 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
33086 : return NULL;
33087 : }
33088 :
33089 :
33090 1 : SWIGINTERN PyObject *_wrap_delete_mapObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33091 : PyObject *resultobj = 0;
33092 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33093 1 : void *argp1 = 0 ;
33094 : int res1 = 0 ;
33095 1 : PyObject * obj0 = 0 ;
33096 :
33097 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_mapObj",&obj0)) SWIG_fail;
33098 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, SWIG_POINTER_DISOWN | 0 );
33099 1 : if (!SWIG_IsOK(res1)) {
33100 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_mapObj" "', argument " "1"" of type '" "struct mapObj *""'");
33101 : }
33102 1 : arg1 = (struct mapObj *)(argp1);
33103 : {
33104 : delete_mapObj(arg1); {
33105 1 : errorObj *ms_error = msGetErrorObj();
33106 :
33107 1 : switch(ms_error->code) {
33108 : case MS_NOERR:
33109 : break;
33110 0 : case MS_NOTFOUND:
33111 0 : msResetErrorList();
33112 0 : break;
33113 : case -1:
33114 : break;
33115 0 : case MS_IOERR:
33116 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33117 0 : _raise_ms_exception();
33118 0 : msResetErrorList();
33119 0 : return NULL;
33120 : }
33121 : default:
33122 0 : _raise_ms_exception();
33123 0 : msResetErrorList();
33124 0 : return NULL;
33125 : }
33126 :
33127 : }
33128 : }
33129 : resultobj = SWIG_Py_Void();
33130 1 : return resultobj;
33131 0 : fail:
33132 : return NULL;
33133 : }
33134 :
33135 :
33136 1 : SWIGINTERN PyObject *_wrap_mapObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33137 : PyObject *resultobj = 0;
33138 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33139 1 : void *argp1 = 0 ;
33140 : int res1 = 0 ;
33141 1 : PyObject * obj0 = 0 ;
33142 : mapObj *result = 0 ;
33143 :
33144 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_clone",&obj0)) SWIG_fail;
33145 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33146 1 : if (!SWIG_IsOK(res1)) {
33147 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_clone" "', argument " "1"" of type '" "struct mapObj *""'");
33148 : }
33149 1 : arg1 = (struct mapObj *)(argp1);
33150 : {
33151 1 : result = (mapObj *)mapObj_clone(arg1); {
33152 1 : errorObj *ms_error = msGetErrorObj();
33153 :
33154 1 : switch(ms_error->code) {
33155 : case MS_NOERR:
33156 : break;
33157 0 : case MS_NOTFOUND:
33158 0 : msResetErrorList();
33159 0 : break;
33160 : case -1:
33161 : break;
33162 0 : case MS_IOERR:
33163 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33164 0 : _raise_ms_exception();
33165 0 : msResetErrorList();
33166 0 : return NULL;
33167 : }
33168 : default:
33169 0 : _raise_ms_exception();
33170 0 : msResetErrorList();
33171 0 : return NULL;
33172 : }
33173 :
33174 : }
33175 : }
33176 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_OWN | 0 );
33177 1 : return resultobj;
33178 0 : fail:
33179 : return NULL;
33180 : }
33181 :
33182 :
33183 1 : SWIGINTERN PyObject *_wrap_mapObj_insertLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33184 : PyObject *resultobj = 0;
33185 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33186 : layerObj *arg2 = (layerObj *) 0 ;
33187 : int arg3 = (int) -1 ;
33188 1 : void *argp1 = 0 ;
33189 : int res1 = 0 ;
33190 1 : void *argp2 = 0 ;
33191 : int res2 = 0 ;
33192 : int val3 ;
33193 : int ecode3 = 0 ;
33194 1 : PyObject * obj0 = 0 ;
33195 1 : PyObject * obj1 = 0 ;
33196 1 : PyObject * obj2 = 0 ;
33197 : int result;
33198 :
33199 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_insertLayer",&obj0,&obj1,&obj2)) SWIG_fail;
33200 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33201 1 : if (!SWIG_IsOK(res1)) {
33202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_insertLayer" "', argument " "1"" of type '" "struct mapObj *""'");
33203 : }
33204 1 : arg1 = (struct mapObj *)(argp1);
33205 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_layerObj, 0 | 0 );
33206 1 : if (!SWIG_IsOK(res2)) {
33207 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_insertLayer" "', argument " "2"" of type '" "layerObj *""'");
33208 : }
33209 1 : arg2 = (layerObj *)(argp2);
33210 1 : if (obj2) {
33211 : ecode3 = SWIG_AsVal_int(obj2, &val3);
33212 1 : if (!SWIG_IsOK(ecode3)) {
33213 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_insertLayer" "', argument " "3"" of type '" "int""'");
33214 : }
33215 : arg3 = (int)(val3);
33216 : }
33217 : {
33218 : result = (int)mapObj_insertLayer(arg1,arg2,arg3); {
33219 1 : errorObj *ms_error = msGetErrorObj();
33220 :
33221 1 : switch(ms_error->code) {
33222 : case MS_NOERR:
33223 : break;
33224 0 : case MS_NOTFOUND:
33225 0 : msResetErrorList();
33226 0 : break;
33227 : case -1:
33228 : break;
33229 0 : case MS_IOERR:
33230 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33231 0 : _raise_ms_exception();
33232 0 : msResetErrorList();
33233 0 : return NULL;
33234 : }
33235 : default:
33236 1 : _raise_ms_exception();
33237 1 : msResetErrorList();
33238 1 : return NULL;
33239 : }
33240 :
33241 : }
33242 : }
33243 : resultobj = SWIG_From_int((int)(result));
33244 1 : return resultobj;
33245 0 : fail:
33246 : return NULL;
33247 : }
33248 :
33249 :
33250 1 : SWIGINTERN PyObject *_wrap_mapObj_removeLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33251 : PyObject *resultobj = 0;
33252 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33253 : int arg2 ;
33254 1 : void *argp1 = 0 ;
33255 : int res1 = 0 ;
33256 : int val2 ;
33257 : int ecode2 = 0 ;
33258 1 : PyObject * obj0 = 0 ;
33259 1 : PyObject * obj1 = 0 ;
33260 : layerObj *result = 0 ;
33261 :
33262 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeLayer",&obj0,&obj1)) SWIG_fail;
33263 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33264 1 : if (!SWIG_IsOK(res1)) {
33265 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeLayer" "', argument " "1"" of type '" "struct mapObj *""'");
33266 : }
33267 1 : arg1 = (struct mapObj *)(argp1);
33268 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
33269 1 : if (!SWIG_IsOK(ecode2)) {
33270 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_removeLayer" "', argument " "2"" of type '" "int""'");
33271 : }
33272 : arg2 = (int)(val2);
33273 : {
33274 : result = (layerObj *)mapObj_removeLayer(arg1,arg2); {
33275 1 : errorObj *ms_error = msGetErrorObj();
33276 :
33277 1 : switch(ms_error->code) {
33278 : case MS_NOERR:
33279 : break;
33280 0 : case MS_NOTFOUND:
33281 0 : msResetErrorList();
33282 0 : break;
33283 : case -1:
33284 : break;
33285 0 : case MS_IOERR:
33286 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33287 0 : _raise_ms_exception();
33288 0 : msResetErrorList();
33289 0 : return NULL;
33290 : }
33291 : default:
33292 0 : _raise_ms_exception();
33293 0 : msResetErrorList();
33294 0 : return NULL;
33295 : }
33296 :
33297 : }
33298 : }
33299 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN | 0 );
33300 1 : return resultobj;
33301 0 : fail:
33302 : return NULL;
33303 : }
33304 :
33305 :
33306 1 : SWIGINTERN PyObject *_wrap_mapObj_setExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33307 : PyObject *resultobj = 0;
33308 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33309 : double arg2 ;
33310 : double arg3 ;
33311 : double arg4 ;
33312 : double arg5 ;
33313 1 : void *argp1 = 0 ;
33314 : int res1 = 0 ;
33315 : double val2 ;
33316 : int ecode2 = 0 ;
33317 : double val3 ;
33318 : int ecode3 = 0 ;
33319 : double val4 ;
33320 : int ecode4 = 0 ;
33321 : double val5 ;
33322 : int ecode5 = 0 ;
33323 1 : PyObject * obj0 = 0 ;
33324 1 : PyObject * obj1 = 0 ;
33325 1 : PyObject * obj2 = 0 ;
33326 1 : PyObject * obj3 = 0 ;
33327 1 : PyObject * obj4 = 0 ;
33328 : int result;
33329 :
33330 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:mapObj_setExtent",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33331 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33332 1 : if (!SWIG_IsOK(res1)) {
33333 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setExtent" "', argument " "1"" of type '" "struct mapObj *""'");
33334 : }
33335 1 : arg1 = (struct mapObj *)(argp1);
33336 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
33337 1 : if (!SWIG_IsOK(ecode2)) {
33338 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setExtent" "', argument " "2"" of type '" "double""'");
33339 : }
33340 1 : arg2 = (double)(val2);
33341 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
33342 1 : if (!SWIG_IsOK(ecode3)) {
33343 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_setExtent" "', argument " "3"" of type '" "double""'");
33344 : }
33345 1 : arg3 = (double)(val3);
33346 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
33347 1 : if (!SWIG_IsOK(ecode4)) {
33348 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_setExtent" "', argument " "4"" of type '" "double""'");
33349 : }
33350 1 : arg4 = (double)(val4);
33351 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
33352 1 : if (!SWIG_IsOK(ecode5)) {
33353 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_setExtent" "', argument " "5"" of type '" "double""'");
33354 : }
33355 1 : arg5 = (double)(val5);
33356 : {
33357 : result = (int)mapObj_setExtent(arg1,arg2,arg3,arg4,arg5); {
33358 1 : errorObj *ms_error = msGetErrorObj();
33359 :
33360 1 : switch(ms_error->code) {
33361 : case MS_NOERR:
33362 : break;
33363 0 : case MS_NOTFOUND:
33364 0 : msResetErrorList();
33365 0 : break;
33366 : case -1:
33367 : break;
33368 0 : case MS_IOERR:
33369 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33370 0 : _raise_ms_exception();
33371 0 : msResetErrorList();
33372 0 : return NULL;
33373 : }
33374 : default:
33375 1 : _raise_ms_exception();
33376 1 : msResetErrorList();
33377 1 : return NULL;
33378 : }
33379 :
33380 : }
33381 : }
33382 : resultobj = SWIG_From_int((int)(result));
33383 1 : return resultobj;
33384 0 : fail:
33385 : return NULL;
33386 : }
33387 :
33388 :
33389 0 : SWIGINTERN PyObject *_wrap_mapObj_offsetExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33390 : PyObject *resultobj = 0;
33391 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33392 : double arg2 ;
33393 : double arg3 ;
33394 0 : void *argp1 = 0 ;
33395 : int res1 = 0 ;
33396 : double val2 ;
33397 : int ecode2 = 0 ;
33398 : double val3 ;
33399 : int ecode3 = 0 ;
33400 0 : PyObject * obj0 = 0 ;
33401 0 : PyObject * obj1 = 0 ;
33402 0 : PyObject * obj2 = 0 ;
33403 : int result;
33404 :
33405 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_offsetExtent",&obj0,&obj1,&obj2)) SWIG_fail;
33406 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33407 0 : if (!SWIG_IsOK(res1)) {
33408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_offsetExtent" "', argument " "1"" of type '" "struct mapObj *""'");
33409 : }
33410 0 : arg1 = (struct mapObj *)(argp1);
33411 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
33412 0 : if (!SWIG_IsOK(ecode2)) {
33413 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_offsetExtent" "', argument " "2"" of type '" "double""'");
33414 : }
33415 0 : arg2 = (double)(val2);
33416 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
33417 0 : if (!SWIG_IsOK(ecode3)) {
33418 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_offsetExtent" "', argument " "3"" of type '" "double""'");
33419 : }
33420 0 : arg3 = (double)(val3);
33421 : {
33422 : result = (int)mapObj_offsetExtent(arg1,arg2,arg3); {
33423 0 : errorObj *ms_error = msGetErrorObj();
33424 :
33425 0 : switch(ms_error->code) {
33426 : case MS_NOERR:
33427 : break;
33428 0 : case MS_NOTFOUND:
33429 0 : msResetErrorList();
33430 0 : break;
33431 : case -1:
33432 : break;
33433 0 : case MS_IOERR:
33434 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33435 0 : _raise_ms_exception();
33436 0 : msResetErrorList();
33437 0 : return NULL;
33438 : }
33439 : default:
33440 0 : _raise_ms_exception();
33441 0 : msResetErrorList();
33442 0 : return NULL;
33443 : }
33444 :
33445 : }
33446 : }
33447 : resultobj = SWIG_From_int((int)(result));
33448 0 : return resultobj;
33449 0 : fail:
33450 : return NULL;
33451 : }
33452 :
33453 :
33454 0 : SWIGINTERN PyObject *_wrap_mapObj_scaleExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33455 : PyObject *resultobj = 0;
33456 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33457 : double arg2 ;
33458 : double arg3 ;
33459 : double arg4 ;
33460 0 : void *argp1 = 0 ;
33461 : int res1 = 0 ;
33462 : double val2 ;
33463 : int ecode2 = 0 ;
33464 : double val3 ;
33465 : int ecode3 = 0 ;
33466 : double val4 ;
33467 : int ecode4 = 0 ;
33468 0 : PyObject * obj0 = 0 ;
33469 0 : PyObject * obj1 = 0 ;
33470 0 : PyObject * obj2 = 0 ;
33471 0 : PyObject * obj3 = 0 ;
33472 : int result;
33473 :
33474 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_scaleExtent",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33475 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33476 0 : if (!SWIG_IsOK(res1)) {
33477 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_scaleExtent" "', argument " "1"" of type '" "struct mapObj *""'");
33478 : }
33479 0 : arg1 = (struct mapObj *)(argp1);
33480 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
33481 0 : if (!SWIG_IsOK(ecode2)) {
33482 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_scaleExtent" "', argument " "2"" of type '" "double""'");
33483 : }
33484 0 : arg2 = (double)(val2);
33485 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
33486 0 : if (!SWIG_IsOK(ecode3)) {
33487 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_scaleExtent" "', argument " "3"" of type '" "double""'");
33488 : }
33489 0 : arg3 = (double)(val3);
33490 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
33491 0 : if (!SWIG_IsOK(ecode4)) {
33492 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_scaleExtent" "', argument " "4"" of type '" "double""'");
33493 : }
33494 0 : arg4 = (double)(val4);
33495 : {
33496 : result = (int)mapObj_scaleExtent(arg1,arg2,arg3,arg4); {
33497 0 : errorObj *ms_error = msGetErrorObj();
33498 :
33499 0 : switch(ms_error->code) {
33500 : case MS_NOERR:
33501 : break;
33502 0 : case MS_NOTFOUND:
33503 0 : msResetErrorList();
33504 0 : break;
33505 : case -1:
33506 : break;
33507 0 : case MS_IOERR:
33508 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33509 0 : _raise_ms_exception();
33510 0 : msResetErrorList();
33511 0 : return NULL;
33512 : }
33513 : default:
33514 0 : _raise_ms_exception();
33515 0 : msResetErrorList();
33516 0 : return NULL;
33517 : }
33518 :
33519 : }
33520 : }
33521 : resultobj = SWIG_From_int((int)(result));
33522 0 : return resultobj;
33523 0 : fail:
33524 : return NULL;
33525 : }
33526 :
33527 :
33528 0 : SWIGINTERN PyObject *_wrap_mapObj_setCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 : PyObject *resultobj = 0;
33530 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33531 : pointObj *arg2 = (pointObj *) 0 ;
33532 0 : void *argp1 = 0 ;
33533 : int res1 = 0 ;
33534 0 : void *argp2 = 0 ;
33535 : int res2 = 0 ;
33536 0 : PyObject * obj0 = 0 ;
33537 0 : PyObject * obj1 = 0 ;
33538 : int result;
33539 :
33540 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setCenter",&obj0,&obj1)) SWIG_fail;
33541 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33542 0 : if (!SWIG_IsOK(res1)) {
33543 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setCenter" "', argument " "1"" of type '" "struct mapObj *""'");
33544 : }
33545 0 : arg1 = (struct mapObj *)(argp1);
33546 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
33547 0 : if (!SWIG_IsOK(res2)) {
33548 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setCenter" "', argument " "2"" of type '" "pointObj *""'");
33549 : }
33550 0 : arg2 = (pointObj *)(argp2);
33551 : {
33552 : result = (int)mapObj_setCenter(arg1,arg2); {
33553 0 : errorObj *ms_error = msGetErrorObj();
33554 :
33555 0 : switch(ms_error->code) {
33556 : case MS_NOERR:
33557 : break;
33558 0 : case MS_NOTFOUND:
33559 0 : msResetErrorList();
33560 0 : break;
33561 : case -1:
33562 : break;
33563 0 : case MS_IOERR:
33564 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33565 0 : _raise_ms_exception();
33566 0 : msResetErrorList();
33567 0 : return NULL;
33568 : }
33569 : default:
33570 0 : _raise_ms_exception();
33571 0 : msResetErrorList();
33572 0 : return NULL;
33573 : }
33574 :
33575 : }
33576 : }
33577 : resultobj = SWIG_From_int((int)(result));
33578 0 : return resultobj;
33579 0 : fail:
33580 : return NULL;
33581 : }
33582 :
33583 :
33584 1 : SWIGINTERN PyObject *_wrap_mapObj_setSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33585 : PyObject *resultobj = 0;
33586 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33587 : int arg2 ;
33588 : int arg3 ;
33589 1 : void *argp1 = 0 ;
33590 : int res1 = 0 ;
33591 : int val2 ;
33592 : int ecode2 = 0 ;
33593 : int val3 ;
33594 : int ecode3 = 0 ;
33595 1 : PyObject * obj0 = 0 ;
33596 1 : PyObject * obj1 = 0 ;
33597 1 : PyObject * obj2 = 0 ;
33598 : int result;
33599 :
33600 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setSize",&obj0,&obj1,&obj2)) SWIG_fail;
33601 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33602 1 : if (!SWIG_IsOK(res1)) {
33603 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setSize" "', argument " "1"" of type '" "struct mapObj *""'");
33604 : }
33605 1 : arg1 = (struct mapObj *)(argp1);
33606 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
33607 1 : if (!SWIG_IsOK(ecode2)) {
33608 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setSize" "', argument " "2"" of type '" "int""'");
33609 : }
33610 : arg2 = (int)(val2);
33611 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
33612 1 : if (!SWIG_IsOK(ecode3)) {
33613 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_setSize" "', argument " "3"" of type '" "int""'");
33614 : }
33615 : arg3 = (int)(val3);
33616 : {
33617 : result = (int)mapObj_setSize(arg1,arg2,arg3); {
33618 1 : errorObj *ms_error = msGetErrorObj();
33619 :
33620 1 : switch(ms_error->code) {
33621 : case MS_NOERR:
33622 : break;
33623 0 : case MS_NOTFOUND:
33624 0 : msResetErrorList();
33625 0 : break;
33626 : case -1:
33627 : break;
33628 0 : case MS_IOERR:
33629 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33630 0 : _raise_ms_exception();
33631 0 : msResetErrorList();
33632 0 : return NULL;
33633 : }
33634 : default:
33635 0 : _raise_ms_exception();
33636 0 : msResetErrorList();
33637 0 : return NULL;
33638 : }
33639 :
33640 : }
33641 : }
33642 : resultobj = SWIG_From_int((int)(result));
33643 1 : return resultobj;
33644 0 : fail:
33645 : return NULL;
33646 : }
33647 :
33648 :
33649 0 : SWIGINTERN PyObject *_wrap_mapObj_pixelToGeoref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33650 : PyObject *resultobj = 0;
33651 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33652 : double arg2 ;
33653 : double arg3 ;
33654 : pointObj *arg4 = (pointObj *) 0 ;
33655 0 : void *argp1 = 0 ;
33656 : int res1 = 0 ;
33657 : double val2 ;
33658 : int ecode2 = 0 ;
33659 : double val3 ;
33660 : int ecode3 = 0 ;
33661 0 : void *argp4 = 0 ;
33662 : int res4 = 0 ;
33663 0 : PyObject * obj0 = 0 ;
33664 0 : PyObject * obj1 = 0 ;
33665 0 : PyObject * obj2 = 0 ;
33666 0 : PyObject * obj3 = 0 ;
33667 :
33668 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_pixelToGeoref",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33669 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33670 0 : if (!SWIG_IsOK(res1)) {
33671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_pixelToGeoref" "', argument " "1"" of type '" "struct mapObj *""'");
33672 : }
33673 0 : arg1 = (struct mapObj *)(argp1);
33674 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
33675 0 : if (!SWIG_IsOK(ecode2)) {
33676 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_pixelToGeoref" "', argument " "2"" of type '" "double""'");
33677 : }
33678 0 : arg2 = (double)(val2);
33679 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
33680 0 : if (!SWIG_IsOK(ecode3)) {
33681 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_pixelToGeoref" "', argument " "3"" of type '" "double""'");
33682 : }
33683 0 : arg3 = (double)(val3);
33684 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_pointObj, 0 | 0 );
33685 0 : if (!SWIG_IsOK(res4)) {
33686 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mapObj_pixelToGeoref" "', argument " "4"" of type '" "pointObj *""'");
33687 : }
33688 0 : arg4 = (pointObj *)(argp4);
33689 : {
33690 : mapObj_pixelToGeoref(arg1,arg2,arg3,arg4); {
33691 0 : errorObj *ms_error = msGetErrorObj();
33692 :
33693 0 : switch(ms_error->code) {
33694 : case MS_NOERR:
33695 : break;
33696 0 : case MS_NOTFOUND:
33697 0 : msResetErrorList();
33698 0 : break;
33699 : case -1:
33700 : break;
33701 0 : case MS_IOERR:
33702 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33703 0 : _raise_ms_exception();
33704 0 : msResetErrorList();
33705 0 : return NULL;
33706 : }
33707 : default:
33708 0 : _raise_ms_exception();
33709 0 : msResetErrorList();
33710 0 : return NULL;
33711 : }
33712 :
33713 : }
33714 : }
33715 : resultobj = SWIG_Py_Void();
33716 0 : return resultobj;
33717 0 : fail:
33718 : return NULL;
33719 : }
33720 :
33721 :
33722 0 : SWIGINTERN PyObject *_wrap_mapObj_getRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33723 : PyObject *resultobj = 0;
33724 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33725 0 : void *argp1 = 0 ;
33726 : int res1 = 0 ;
33727 0 : PyObject * obj0 = 0 ;
33728 : double result;
33729 :
33730 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getRotation",&obj0)) SWIG_fail;
33731 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33732 0 : if (!SWIG_IsOK(res1)) {
33733 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getRotation" "', argument " "1"" of type '" "struct mapObj *""'");
33734 : }
33735 0 : arg1 = (struct mapObj *)(argp1);
33736 : {
33737 0 : result = (double)mapObj_getRotation(arg1); {
33738 0 : errorObj *ms_error = msGetErrorObj();
33739 :
33740 0 : switch(ms_error->code) {
33741 : case MS_NOERR:
33742 : break;
33743 0 : case MS_NOTFOUND:
33744 0 : msResetErrorList();
33745 0 : break;
33746 : case -1:
33747 : break;
33748 0 : case MS_IOERR:
33749 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33750 0 : _raise_ms_exception();
33751 0 : msResetErrorList();
33752 0 : return NULL;
33753 : }
33754 : default:
33755 0 : _raise_ms_exception();
33756 0 : msResetErrorList();
33757 0 : return NULL;
33758 : }
33759 :
33760 : }
33761 : }
33762 0 : resultobj = SWIG_From_double((double)(result));
33763 0 : return resultobj;
33764 0 : fail:
33765 : return NULL;
33766 : }
33767 :
33768 :
33769 0 : SWIGINTERN PyObject *_wrap_mapObj_setRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33770 : PyObject *resultobj = 0;
33771 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33772 : double arg2 ;
33773 0 : void *argp1 = 0 ;
33774 : int res1 = 0 ;
33775 : double val2 ;
33776 : int ecode2 = 0 ;
33777 0 : PyObject * obj0 = 0 ;
33778 0 : PyObject * obj1 = 0 ;
33779 : int result;
33780 :
33781 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setRotation",&obj0,&obj1)) SWIG_fail;
33782 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33783 0 : if (!SWIG_IsOK(res1)) {
33784 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setRotation" "', argument " "1"" of type '" "struct mapObj *""'");
33785 : }
33786 0 : arg1 = (struct mapObj *)(argp1);
33787 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
33788 0 : if (!SWIG_IsOK(ecode2)) {
33789 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_setRotation" "', argument " "2"" of type '" "double""'");
33790 : }
33791 0 : arg2 = (double)(val2);
33792 : {
33793 : result = (int)mapObj_setRotation(arg1,arg2); {
33794 0 : errorObj *ms_error = msGetErrorObj();
33795 :
33796 0 : switch(ms_error->code) {
33797 : case MS_NOERR:
33798 : break;
33799 0 : case MS_NOTFOUND:
33800 0 : msResetErrorList();
33801 0 : break;
33802 : case -1:
33803 : break;
33804 0 : case MS_IOERR:
33805 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33806 0 : _raise_ms_exception();
33807 0 : msResetErrorList();
33808 0 : return NULL;
33809 : }
33810 : default:
33811 0 : _raise_ms_exception();
33812 0 : msResetErrorList();
33813 0 : return NULL;
33814 : }
33815 :
33816 : }
33817 : }
33818 : resultobj = SWIG_From_int((int)(result));
33819 0 : return resultobj;
33820 0 : fail:
33821 : return NULL;
33822 : }
33823 :
33824 :
33825 1 : SWIGINTERN PyObject *_wrap_mapObj_getLayer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33826 : PyObject *resultobj = 0;
33827 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33828 : int arg2 ;
33829 1 : void *argp1 = 0 ;
33830 : int res1 = 0 ;
33831 : int val2 ;
33832 : int ecode2 = 0 ;
33833 1 : PyObject * obj0 = 0 ;
33834 1 : PyObject * obj1 = 0 ;
33835 : layerObj *result = 0 ;
33836 :
33837 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getLayer",&obj0,&obj1)) SWIG_fail;
33838 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33839 1 : if (!SWIG_IsOK(res1)) {
33840 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayer" "', argument " "1"" of type '" "struct mapObj *""'");
33841 : }
33842 1 : arg1 = (struct mapObj *)(argp1);
33843 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
33844 1 : if (!SWIG_IsOK(ecode2)) {
33845 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_getLayer" "', argument " "2"" of type '" "int""'");
33846 : }
33847 : arg2 = (int)(val2);
33848 : {
33849 1 : result = (layerObj *)mapObj_getLayer(arg1,arg2); {
33850 1 : errorObj *ms_error = msGetErrorObj();
33851 :
33852 1 : switch(ms_error->code) {
33853 : case MS_NOERR:
33854 : break;
33855 0 : case MS_NOTFOUND:
33856 0 : msResetErrorList();
33857 0 : break;
33858 : case -1:
33859 : break;
33860 0 : case MS_IOERR:
33861 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33862 0 : _raise_ms_exception();
33863 0 : msResetErrorList();
33864 0 : return NULL;
33865 : }
33866 : default:
33867 0 : _raise_ms_exception();
33868 0 : msResetErrorList();
33869 0 : return NULL;
33870 : }
33871 :
33872 : }
33873 : }
33874 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN | 0 );
33875 1 : return resultobj;
33876 0 : fail:
33877 : return NULL;
33878 : }
33879 :
33880 :
33881 1 : SWIGINTERN PyObject *_wrap_mapObj_getLayerByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33882 : PyObject *resultobj = 0;
33883 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33884 : char *arg2 = (char *) 0 ;
33885 1 : void *argp1 = 0 ;
33886 : int res1 = 0 ;
33887 : int res2 ;
33888 1 : char *buf2 = 0 ;
33889 1 : int alloc2 = 0 ;
33890 1 : PyObject * obj0 = 0 ;
33891 1 : PyObject * obj1 = 0 ;
33892 : layerObj *result = 0 ;
33893 :
33894 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getLayerByName",&obj0,&obj1)) SWIG_fail;
33895 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33896 1 : if (!SWIG_IsOK(res1)) {
33897 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayerByName" "', argument " "1"" of type '" "struct mapObj *""'");
33898 : }
33899 1 : arg1 = (struct mapObj *)(argp1);
33900 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33901 1 : if (!SWIG_IsOK(res2)) {
33902 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getLayerByName" "', argument " "2"" of type '" "char *""'");
33903 : }
33904 1 : arg2 = (char *)(buf2);
33905 : {
33906 1 : result = (layerObj *)mapObj_getLayerByName(arg1,arg2); {
33907 1 : errorObj *ms_error = msGetErrorObj();
33908 :
33909 1 : switch(ms_error->code) {
33910 : case MS_NOERR:
33911 : break;
33912 0 : case MS_NOTFOUND:
33913 0 : msResetErrorList();
33914 0 : break;
33915 : case -1:
33916 : break;
33917 0 : case MS_IOERR:
33918 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33919 0 : _raise_ms_exception();
33920 0 : msResetErrorList();
33921 0 : return NULL;
33922 : }
33923 : default:
33924 0 : _raise_ms_exception();
33925 0 : msResetErrorList();
33926 0 : return NULL;
33927 : }
33928 :
33929 : }
33930 : }
33931 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_layerObj, SWIG_POINTER_OWN | 0 );
33932 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33933 : return resultobj;
33934 0 : fail:
33935 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33936 : return NULL;
33937 : }
33938 :
33939 :
33940 0 : SWIGINTERN PyObject *_wrap_mapObj_getSymbolByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33941 : PyObject *resultobj = 0;
33942 : struct mapObj *arg1 = (struct mapObj *) 0 ;
33943 : char *arg2 = (char *) 0 ;
33944 0 : void *argp1 = 0 ;
33945 : int res1 = 0 ;
33946 : int res2 ;
33947 0 : char *buf2 = 0 ;
33948 0 : int alloc2 = 0 ;
33949 0 : PyObject * obj0 = 0 ;
33950 0 : PyObject * obj1 = 0 ;
33951 : int result;
33952 :
33953 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getSymbolByName",&obj0,&obj1)) SWIG_fail;
33954 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
33955 0 : if (!SWIG_IsOK(res1)) {
33956 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getSymbolByName" "', argument " "1"" of type '" "struct mapObj *""'");
33957 : }
33958 0 : arg1 = (struct mapObj *)(argp1);
33959 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33960 0 : if (!SWIG_IsOK(res2)) {
33961 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getSymbolByName" "', argument " "2"" of type '" "char *""'");
33962 : }
33963 0 : arg2 = (char *)(buf2);
33964 : {
33965 : result = (int)mapObj_getSymbolByName(arg1,arg2); {
33966 0 : errorObj *ms_error = msGetErrorObj();
33967 :
33968 0 : switch(ms_error->code) {
33969 : case MS_NOERR:
33970 : break;
33971 0 : case MS_NOTFOUND:
33972 0 : msResetErrorList();
33973 0 : break;
33974 : case -1:
33975 : break;
33976 0 : case MS_IOERR:
33977 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
33978 0 : _raise_ms_exception();
33979 0 : msResetErrorList();
33980 0 : return NULL;
33981 : }
33982 : default:
33983 0 : _raise_ms_exception();
33984 0 : msResetErrorList();
33985 0 : return NULL;
33986 : }
33987 :
33988 : }
33989 : }
33990 : resultobj = SWIG_From_int((int)(result));
33991 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33992 : return resultobj;
33993 0 : fail:
33994 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33995 : return NULL;
33996 : }
33997 :
33998 :
33999 0 : SWIGINTERN PyObject *_wrap_mapObj_prepareQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34000 : PyObject *resultobj = 0;
34001 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34002 0 : void *argp1 = 0 ;
34003 : int res1 = 0 ;
34004 0 : PyObject * obj0 = 0 ;
34005 :
34006 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_prepareQuery",&obj0)) SWIG_fail;
34007 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34008 0 : if (!SWIG_IsOK(res1)) {
34009 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_prepareQuery" "', argument " "1"" of type '" "struct mapObj *""'");
34010 : }
34011 0 : arg1 = (struct mapObj *)(argp1);
34012 : {
34013 0 : mapObj_prepareQuery(arg1); {
34014 0 : errorObj *ms_error = msGetErrorObj();
34015 :
34016 0 : switch(ms_error->code) {
34017 : case MS_NOERR:
34018 : break;
34019 0 : case MS_NOTFOUND:
34020 0 : msResetErrorList();
34021 0 : break;
34022 : case -1:
34023 : break;
34024 0 : case MS_IOERR:
34025 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34026 0 : _raise_ms_exception();
34027 0 : msResetErrorList();
34028 0 : return NULL;
34029 : }
34030 : default:
34031 0 : _raise_ms_exception();
34032 0 : msResetErrorList();
34033 0 : return NULL;
34034 : }
34035 :
34036 : }
34037 : }
34038 : resultobj = SWIG_Py_Void();
34039 0 : return resultobj;
34040 0 : fail:
34041 : return NULL;
34042 : }
34043 :
34044 :
34045 1 : SWIGINTERN PyObject *_wrap_mapObj_prepareImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34046 : PyObject *resultobj = 0;
34047 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34048 1 : void *argp1 = 0 ;
34049 : int res1 = 0 ;
34050 1 : PyObject * obj0 = 0 ;
34051 : imageObj *result = 0 ;
34052 :
34053 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_prepareImage",&obj0)) SWIG_fail;
34054 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34055 1 : if (!SWIG_IsOK(res1)) {
34056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_prepareImage" "', argument " "1"" of type '" "struct mapObj *""'");
34057 : }
34058 1 : arg1 = (struct mapObj *)(argp1);
34059 : {
34060 : result = (imageObj *)mapObj_prepareImage(arg1); {
34061 1 : errorObj *ms_error = msGetErrorObj();
34062 :
34063 1 : switch(ms_error->code) {
34064 : case MS_NOERR:
34065 : break;
34066 0 : case MS_NOTFOUND:
34067 0 : msResetErrorList();
34068 0 : break;
34069 : case -1:
34070 : break;
34071 0 : case MS_IOERR:
34072 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34073 0 : _raise_ms_exception();
34074 0 : msResetErrorList();
34075 0 : return NULL;
34076 : }
34077 : default:
34078 0 : _raise_ms_exception();
34079 0 : msResetErrorList();
34080 0 : return NULL;
34081 : }
34082 :
34083 : }
34084 : }
34085 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34086 1 : return resultobj;
34087 0 : fail:
34088 : return NULL;
34089 : }
34090 :
34091 :
34092 1 : SWIGINTERN PyObject *_wrap_mapObj_setImageType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34093 : PyObject *resultobj = 0;
34094 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34095 : char *arg2 = (char *) 0 ;
34096 1 : void *argp1 = 0 ;
34097 : int res1 = 0 ;
34098 : int res2 ;
34099 1 : char *buf2 = 0 ;
34100 1 : int alloc2 = 0 ;
34101 1 : PyObject * obj0 = 0 ;
34102 1 : PyObject * obj1 = 0 ;
34103 :
34104 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setImageType",&obj0,&obj1)) SWIG_fail;
34105 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34106 1 : if (!SWIG_IsOK(res1)) {
34107 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setImageType" "', argument " "1"" of type '" "struct mapObj *""'");
34108 : }
34109 1 : arg1 = (struct mapObj *)(argp1);
34110 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34111 1 : if (!SWIG_IsOK(res2)) {
34112 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setImageType" "', argument " "2"" of type '" "char *""'");
34113 : }
34114 1 : arg2 = (char *)(buf2);
34115 : {
34116 1 : mapObj_setImageType(arg1,arg2); {
34117 1 : errorObj *ms_error = msGetErrorObj();
34118 :
34119 1 : switch(ms_error->code) {
34120 : case MS_NOERR:
34121 : break;
34122 0 : case MS_NOTFOUND:
34123 0 : msResetErrorList();
34124 0 : break;
34125 : case -1:
34126 : break;
34127 0 : case MS_IOERR:
34128 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34129 0 : _raise_ms_exception();
34130 0 : msResetErrorList();
34131 0 : return NULL;
34132 : }
34133 : default:
34134 0 : _raise_ms_exception();
34135 0 : msResetErrorList();
34136 0 : return NULL;
34137 : }
34138 :
34139 : }
34140 : }
34141 : resultobj = SWIG_Py_Void();
34142 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34143 : return resultobj;
34144 0 : fail:
34145 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34146 : return NULL;
34147 : }
34148 :
34149 :
34150 1 : SWIGINTERN PyObject *_wrap_mapObj_selectOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34151 : PyObject *resultobj = 0;
34152 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34153 : char *arg2 = (char *) 0 ;
34154 1 : void *argp1 = 0 ;
34155 : int res1 = 0 ;
34156 : int res2 ;
34157 1 : char *buf2 = 0 ;
34158 1 : int alloc2 = 0 ;
34159 1 : PyObject * obj0 = 0 ;
34160 1 : PyObject * obj1 = 0 ;
34161 :
34162 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_selectOutputFormat",&obj0,&obj1)) SWIG_fail;
34163 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34164 1 : if (!SWIG_IsOK(res1)) {
34165 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_selectOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'");
34166 : }
34167 1 : arg1 = (struct mapObj *)(argp1);
34168 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34169 1 : if (!SWIG_IsOK(res2)) {
34170 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_selectOutputFormat" "', argument " "2"" of type '" "char *""'");
34171 : }
34172 1 : arg2 = (char *)(buf2);
34173 : {
34174 1 : mapObj_selectOutputFormat(arg1,arg2); {
34175 1 : errorObj *ms_error = msGetErrorObj();
34176 :
34177 1 : switch(ms_error->code) {
34178 : case MS_NOERR:
34179 : break;
34180 0 : case MS_NOTFOUND:
34181 0 : msResetErrorList();
34182 0 : break;
34183 : case -1:
34184 : break;
34185 0 : case MS_IOERR:
34186 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34187 0 : _raise_ms_exception();
34188 0 : msResetErrorList();
34189 0 : return NULL;
34190 : }
34191 : default:
34192 1 : _raise_ms_exception();
34193 1 : msResetErrorList();
34194 1 : return NULL;
34195 : }
34196 :
34197 : }
34198 : }
34199 : resultobj = SWIG_Py_Void();
34200 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34201 : return resultobj;
34202 0 : fail:
34203 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34204 : return NULL;
34205 : }
34206 :
34207 :
34208 0 : SWIGINTERN PyObject *_wrap_mapObj_getOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 : PyObject *resultobj = 0;
34210 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34211 : int arg2 ;
34212 0 : void *argp1 = 0 ;
34213 : int res1 = 0 ;
34214 : int val2 ;
34215 : int ecode2 = 0 ;
34216 0 : PyObject * obj0 = 0 ;
34217 0 : PyObject * obj1 = 0 ;
34218 : outputFormatObj *result = 0 ;
34219 :
34220 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getOutputFormat",&obj0,&obj1)) SWIG_fail;
34221 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34222 0 : if (!SWIG_IsOK(res1)) {
34223 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'");
34224 : }
34225 0 : arg1 = (struct mapObj *)(argp1);
34226 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34227 0 : if (!SWIG_IsOK(ecode2)) {
34228 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_getOutputFormat" "', argument " "2"" of type '" "int""'");
34229 : }
34230 : arg2 = (int)(val2);
34231 : {
34232 0 : result = (outputFormatObj *)mapObj_getOutputFormat(arg1,arg2); {
34233 0 : errorObj *ms_error = msGetErrorObj();
34234 :
34235 0 : switch(ms_error->code) {
34236 : case MS_NOERR:
34237 : break;
34238 0 : case MS_NOTFOUND:
34239 0 : msResetErrorList();
34240 0 : break;
34241 : case -1:
34242 : break;
34243 0 : case MS_IOERR:
34244 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34245 0 : _raise_ms_exception();
34246 0 : msResetErrorList();
34247 0 : return NULL;
34248 : }
34249 : default:
34250 0 : _raise_ms_exception();
34251 0 : msResetErrorList();
34252 0 : return NULL;
34253 : }
34254 :
34255 : }
34256 : }
34257 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, SWIG_POINTER_OWN | 0 );
34258 0 : return resultobj;
34259 0 : fail:
34260 : return NULL;
34261 : }
34262 :
34263 :
34264 0 : SWIGINTERN PyObject *_wrap_mapObj_setOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34265 : PyObject *resultobj = 0;
34266 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34267 : outputFormatObj *arg2 = (outputFormatObj *) 0 ;
34268 0 : void *argp1 = 0 ;
34269 : int res1 = 0 ;
34270 0 : void *argp2 = 0 ;
34271 : int res2 = 0 ;
34272 0 : PyObject * obj0 = 0 ;
34273 0 : PyObject * obj1 = 0 ;
34274 :
34275 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setOutputFormat",&obj0,&obj1)) SWIG_fail;
34276 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34277 0 : if (!SWIG_IsOK(res1)) {
34278 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'");
34279 : }
34280 0 : arg1 = (struct mapObj *)(argp1);
34281 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 | 0 );
34282 0 : if (!SWIG_IsOK(res2)) {
34283 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setOutputFormat" "', argument " "2"" of type '" "outputFormatObj *""'");
34284 : }
34285 0 : arg2 = (outputFormatObj *)(argp2);
34286 : {
34287 : mapObj_setOutputFormat(arg1,arg2); {
34288 0 : errorObj *ms_error = msGetErrorObj();
34289 :
34290 0 : switch(ms_error->code) {
34291 : case MS_NOERR:
34292 : break;
34293 0 : case MS_NOTFOUND:
34294 0 : msResetErrorList();
34295 0 : break;
34296 : case -1:
34297 : break;
34298 0 : case MS_IOERR:
34299 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34300 0 : _raise_ms_exception();
34301 0 : msResetErrorList();
34302 0 : return NULL;
34303 : }
34304 : default:
34305 0 : _raise_ms_exception();
34306 0 : msResetErrorList();
34307 0 : return NULL;
34308 : }
34309 :
34310 : }
34311 : }
34312 : resultobj = SWIG_Py_Void();
34313 0 : return resultobj;
34314 0 : fail:
34315 : return NULL;
34316 : }
34317 :
34318 :
34319 1 : SWIGINTERN PyObject *_wrap_mapObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34320 : PyObject *resultobj = 0;
34321 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34322 1 : void *argp1 = 0 ;
34323 : int res1 = 0 ;
34324 1 : PyObject * obj0 = 0 ;
34325 : imageObj *result = 0 ;
34326 :
34327 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_draw",&obj0)) SWIG_fail;
34328 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34329 1 : if (!SWIG_IsOK(res1)) {
34330 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_draw" "', argument " "1"" of type '" "struct mapObj *""'");
34331 : }
34332 1 : arg1 = (struct mapObj *)(argp1);
34333 : {
34334 : result = (imageObj *)mapObj_draw(arg1); {
34335 1 : errorObj *ms_error = msGetErrorObj();
34336 :
34337 1 : switch(ms_error->code) {
34338 : case MS_NOERR:
34339 : break;
34340 0 : case MS_NOTFOUND:
34341 0 : msResetErrorList();
34342 0 : break;
34343 : case -1:
34344 : break;
34345 0 : case MS_IOERR:
34346 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34347 0 : _raise_ms_exception();
34348 0 : msResetErrorList();
34349 0 : return NULL;
34350 : }
34351 : default:
34352 1 : _raise_ms_exception();
34353 1 : msResetErrorList();
34354 1 : return NULL;
34355 : }
34356 :
34357 : }
34358 : }
34359 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34360 1 : return resultobj;
34361 0 : fail:
34362 : return NULL;
34363 : }
34364 :
34365 :
34366 0 : SWIGINTERN PyObject *_wrap_mapObj_drawQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34367 : PyObject *resultobj = 0;
34368 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34369 0 : void *argp1 = 0 ;
34370 : int res1 = 0 ;
34371 0 : PyObject * obj0 = 0 ;
34372 : imageObj *result = 0 ;
34373 :
34374 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawQuery",&obj0)) SWIG_fail;
34375 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34376 0 : if (!SWIG_IsOK(res1)) {
34377 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawQuery" "', argument " "1"" of type '" "struct mapObj *""'");
34378 : }
34379 0 : arg1 = (struct mapObj *)(argp1);
34380 : {
34381 : result = (imageObj *)mapObj_drawQuery(arg1); {
34382 0 : errorObj *ms_error = msGetErrorObj();
34383 :
34384 0 : switch(ms_error->code) {
34385 : case MS_NOERR:
34386 : break;
34387 0 : case MS_NOTFOUND:
34388 0 : msResetErrorList();
34389 0 : break;
34390 : case -1:
34391 : break;
34392 0 : case MS_IOERR:
34393 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34394 0 : _raise_ms_exception();
34395 0 : msResetErrorList();
34396 0 : return NULL;
34397 : }
34398 : default:
34399 0 : _raise_ms_exception();
34400 0 : msResetErrorList();
34401 0 : return NULL;
34402 : }
34403 :
34404 : }
34405 : }
34406 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34407 0 : return resultobj;
34408 0 : fail:
34409 : return NULL;
34410 : }
34411 :
34412 :
34413 0 : SWIGINTERN PyObject *_wrap_mapObj_drawLegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34414 : PyObject *resultobj = 0;
34415 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34416 : int arg2 = (int) 0 ;
34417 0 : void *argp1 = 0 ;
34418 : int res1 = 0 ;
34419 : int val2 ;
34420 : int ecode2 = 0 ;
34421 0 : PyObject * obj0 = 0 ;
34422 0 : PyObject * obj1 = 0 ;
34423 : imageObj *result = 0 ;
34424 :
34425 0 : if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_drawLegend",&obj0,&obj1)) SWIG_fail;
34426 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34427 0 : if (!SWIG_IsOK(res1)) {
34428 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawLegend" "', argument " "1"" of type '" "struct mapObj *""'");
34429 : }
34430 0 : arg1 = (struct mapObj *)(argp1);
34431 0 : if (obj1) {
34432 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34433 0 : if (!SWIG_IsOK(ecode2)) {
34434 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_drawLegend" "', argument " "2"" of type '" "int""'");
34435 : }
34436 : arg2 = (int)(val2);
34437 : }
34438 : {
34439 : result = (imageObj *)mapObj_drawLegend(arg1,arg2); {
34440 0 : errorObj *ms_error = msGetErrorObj();
34441 :
34442 0 : switch(ms_error->code) {
34443 : case MS_NOERR:
34444 : break;
34445 0 : case MS_NOTFOUND:
34446 0 : msResetErrorList();
34447 0 : break;
34448 : case -1:
34449 : break;
34450 0 : case MS_IOERR:
34451 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34452 0 : _raise_ms_exception();
34453 0 : msResetErrorList();
34454 0 : return NULL;
34455 : }
34456 : default:
34457 0 : _raise_ms_exception();
34458 0 : msResetErrorList();
34459 0 : return NULL;
34460 : }
34461 :
34462 : }
34463 : }
34464 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34465 0 : return resultobj;
34466 0 : fail:
34467 : return NULL;
34468 : }
34469 :
34470 :
34471 0 : SWIGINTERN PyObject *_wrap_mapObj_drawScalebar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34472 : PyObject *resultobj = 0;
34473 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34474 0 : void *argp1 = 0 ;
34475 : int res1 = 0 ;
34476 0 : PyObject * obj0 = 0 ;
34477 : imageObj *result = 0 ;
34478 :
34479 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawScalebar",&obj0)) SWIG_fail;
34480 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34481 0 : if (!SWIG_IsOK(res1)) {
34482 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawScalebar" "', argument " "1"" of type '" "struct mapObj *""'");
34483 : }
34484 0 : arg1 = (struct mapObj *)(argp1);
34485 : {
34486 : result = (imageObj *)mapObj_drawScalebar(arg1); {
34487 0 : errorObj *ms_error = msGetErrorObj();
34488 :
34489 0 : switch(ms_error->code) {
34490 : case MS_NOERR:
34491 : break;
34492 0 : case MS_NOTFOUND:
34493 0 : msResetErrorList();
34494 0 : break;
34495 : case -1:
34496 : break;
34497 0 : case MS_IOERR:
34498 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34499 0 : _raise_ms_exception();
34500 0 : msResetErrorList();
34501 0 : return NULL;
34502 : }
34503 : default:
34504 0 : _raise_ms_exception();
34505 0 : msResetErrorList();
34506 0 : return NULL;
34507 : }
34508 :
34509 : }
34510 : }
34511 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34512 0 : return resultobj;
34513 0 : fail:
34514 : return NULL;
34515 : }
34516 :
34517 :
34518 0 : SWIGINTERN PyObject *_wrap_mapObj_drawReferenceMap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34519 : PyObject *resultobj = 0;
34520 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34521 0 : void *argp1 = 0 ;
34522 : int res1 = 0 ;
34523 0 : PyObject * obj0 = 0 ;
34524 : imageObj *result = 0 ;
34525 :
34526 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_drawReferenceMap",&obj0)) SWIG_fail;
34527 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34528 0 : if (!SWIG_IsOK(res1)) {
34529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawReferenceMap" "', argument " "1"" of type '" "struct mapObj *""'");
34530 : }
34531 0 : arg1 = (struct mapObj *)(argp1);
34532 : {
34533 : result = (imageObj *)mapObj_drawReferenceMap(arg1); {
34534 0 : errorObj *ms_error = msGetErrorObj();
34535 :
34536 0 : switch(ms_error->code) {
34537 : case MS_NOERR:
34538 : break;
34539 0 : case MS_NOTFOUND:
34540 0 : msResetErrorList();
34541 0 : break;
34542 : case -1:
34543 : break;
34544 0 : case MS_IOERR:
34545 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34546 0 : _raise_ms_exception();
34547 0 : msResetErrorList();
34548 0 : return NULL;
34549 : }
34550 : default:
34551 0 : _raise_ms_exception();
34552 0 : msResetErrorList();
34553 0 : return NULL;
34554 : }
34555 :
34556 : }
34557 : }
34558 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
34559 0 : return resultobj;
34560 0 : fail:
34561 : return NULL;
34562 : }
34563 :
34564 :
34565 0 : SWIGINTERN PyObject *_wrap_mapObj_embedScalebar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34566 : PyObject *resultobj = 0;
34567 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34568 : imageObj *arg2 = (imageObj *) 0 ;
34569 0 : void *argp1 = 0 ;
34570 : int res1 = 0 ;
34571 0 : void *argp2 = 0 ;
34572 : int res2 = 0 ;
34573 0 : PyObject * obj0 = 0 ;
34574 0 : PyObject * obj1 = 0 ;
34575 : int result;
34576 :
34577 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_embedScalebar",&obj0,&obj1)) SWIG_fail;
34578 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34579 0 : if (!SWIG_IsOK(res1)) {
34580 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_embedScalebar" "', argument " "1"" of type '" "struct mapObj *""'");
34581 : }
34582 0 : arg1 = (struct mapObj *)(argp1);
34583 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 | 0 );
34584 0 : if (!SWIG_IsOK(res2)) {
34585 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_embedScalebar" "', argument " "2"" of type '" "imageObj *""'");
34586 : }
34587 0 : arg2 = (imageObj *)(argp2);
34588 : {
34589 : result = (int)mapObj_embedScalebar(arg1,arg2); {
34590 0 : errorObj *ms_error = msGetErrorObj();
34591 :
34592 0 : switch(ms_error->code) {
34593 : case MS_NOERR:
34594 : break;
34595 0 : case MS_NOTFOUND:
34596 0 : msResetErrorList();
34597 0 : break;
34598 : case -1:
34599 : break;
34600 0 : case MS_IOERR:
34601 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34602 0 : _raise_ms_exception();
34603 0 : msResetErrorList();
34604 0 : return NULL;
34605 : }
34606 : default:
34607 0 : _raise_ms_exception();
34608 0 : msResetErrorList();
34609 0 : return NULL;
34610 : }
34611 :
34612 : }
34613 : }
34614 : resultobj = SWIG_From_int((int)(result));
34615 0 : return resultobj;
34616 0 : fail:
34617 : return NULL;
34618 : }
34619 :
34620 :
34621 0 : SWIGINTERN PyObject *_wrap_mapObj_embedLegend(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34622 : PyObject *resultobj = 0;
34623 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34624 : imageObj *arg2 = (imageObj *) 0 ;
34625 0 : void *argp1 = 0 ;
34626 : int res1 = 0 ;
34627 0 : void *argp2 = 0 ;
34628 : int res2 = 0 ;
34629 0 : PyObject * obj0 = 0 ;
34630 0 : PyObject * obj1 = 0 ;
34631 : int result;
34632 :
34633 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_embedLegend",&obj0,&obj1)) SWIG_fail;
34634 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34635 0 : if (!SWIG_IsOK(res1)) {
34636 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_embedLegend" "', argument " "1"" of type '" "struct mapObj *""'");
34637 : }
34638 0 : arg1 = (struct mapObj *)(argp1);
34639 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 | 0 );
34640 0 : if (!SWIG_IsOK(res2)) {
34641 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_embedLegend" "', argument " "2"" of type '" "imageObj *""'");
34642 : }
34643 0 : arg2 = (imageObj *)(argp2);
34644 : {
34645 : result = (int)mapObj_embedLegend(arg1,arg2); {
34646 0 : errorObj *ms_error = msGetErrorObj();
34647 :
34648 0 : switch(ms_error->code) {
34649 : case MS_NOERR:
34650 : break;
34651 0 : case MS_NOTFOUND:
34652 0 : msResetErrorList();
34653 0 : break;
34654 : case -1:
34655 : break;
34656 0 : case MS_IOERR:
34657 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34658 0 : _raise_ms_exception();
34659 0 : msResetErrorList();
34660 0 : return NULL;
34661 : }
34662 : default:
34663 0 : _raise_ms_exception();
34664 0 : msResetErrorList();
34665 0 : return NULL;
34666 : }
34667 :
34668 : }
34669 : }
34670 : resultobj = SWIG_From_int((int)(result));
34671 0 : return resultobj;
34672 0 : fail:
34673 : return NULL;
34674 : }
34675 :
34676 :
34677 0 : SWIGINTERN PyObject *_wrap_mapObj_drawLabelCache(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34678 : PyObject *resultobj = 0;
34679 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34680 : imageObj *arg2 = (imageObj *) 0 ;
34681 0 : void *argp1 = 0 ;
34682 : int res1 = 0 ;
34683 0 : void *argp2 = 0 ;
34684 : int res2 = 0 ;
34685 0 : PyObject * obj0 = 0 ;
34686 0 : PyObject * obj1 = 0 ;
34687 : int result;
34688 :
34689 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_drawLabelCache",&obj0,&obj1)) SWIG_fail;
34690 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34691 0 : if (!SWIG_IsOK(res1)) {
34692 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_drawLabelCache" "', argument " "1"" of type '" "struct mapObj *""'");
34693 : }
34694 0 : arg1 = (struct mapObj *)(argp1);
34695 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 | 0 );
34696 0 : if (!SWIG_IsOK(res2)) {
34697 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_drawLabelCache" "', argument " "2"" of type '" "imageObj *""'");
34698 : }
34699 0 : arg2 = (imageObj *)(argp2);
34700 : {
34701 : result = (int)mapObj_drawLabelCache(arg1,arg2); {
34702 0 : errorObj *ms_error = msGetErrorObj();
34703 :
34704 0 : switch(ms_error->code) {
34705 : case MS_NOERR:
34706 : break;
34707 0 : case MS_NOTFOUND:
34708 0 : msResetErrorList();
34709 0 : break;
34710 : case -1:
34711 : break;
34712 0 : case MS_IOERR:
34713 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34714 0 : _raise_ms_exception();
34715 0 : msResetErrorList();
34716 0 : return NULL;
34717 : }
34718 : default:
34719 0 : _raise_ms_exception();
34720 0 : msResetErrorList();
34721 0 : return NULL;
34722 : }
34723 :
34724 : }
34725 : }
34726 : resultobj = SWIG_From_int((int)(result));
34727 0 : return resultobj;
34728 0 : fail:
34729 : return NULL;
34730 : }
34731 :
34732 :
34733 0 : SWIGINTERN PyObject *_wrap_mapObj_queryByFilter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34734 : PyObject *resultobj = 0;
34735 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34736 : char *arg2 = (char *) 0 ;
34737 0 : void *argp1 = 0 ;
34738 : int res1 = 0 ;
34739 : int res2 ;
34740 0 : char *buf2 = 0 ;
34741 0 : int alloc2 = 0 ;
34742 0 : PyObject * obj0 = 0 ;
34743 0 : PyObject * obj1 = 0 ;
34744 : int result;
34745 :
34746 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByFilter",&obj0,&obj1)) SWIG_fail;
34747 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34748 0 : if (!SWIG_IsOK(res1)) {
34749 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByFilter" "', argument " "1"" of type '" "struct mapObj *""'");
34750 : }
34751 0 : arg1 = (struct mapObj *)(argp1);
34752 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34753 0 : if (!SWIG_IsOK(res2)) {
34754 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByFilter" "', argument " "2"" of type '" "char *""'");
34755 : }
34756 0 : arg2 = (char *)(buf2);
34757 : {
34758 0 : result = (int)mapObj_queryByFilter(arg1,arg2); {
34759 0 : errorObj *ms_error = msGetErrorObj();
34760 :
34761 0 : switch(ms_error->code) {
34762 : case MS_NOERR:
34763 : break;
34764 0 : case MS_NOTFOUND:
34765 0 : msResetErrorList();
34766 0 : break;
34767 : case -1:
34768 : break;
34769 0 : case MS_IOERR:
34770 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34771 0 : _raise_ms_exception();
34772 0 : msResetErrorList();
34773 0 : return NULL;
34774 : }
34775 : default:
34776 0 : _raise_ms_exception();
34777 0 : msResetErrorList();
34778 0 : return NULL;
34779 : }
34780 :
34781 : }
34782 : }
34783 : resultobj = SWIG_From_int((int)(result));
34784 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34785 : return resultobj;
34786 0 : fail:
34787 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34788 : return NULL;
34789 : }
34790 :
34791 :
34792 1 : SWIGINTERN PyObject *_wrap_mapObj_queryByPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34793 : PyObject *resultobj = 0;
34794 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34795 : pointObj *arg2 = (pointObj *) 0 ;
34796 : int arg3 ;
34797 : double arg4 ;
34798 1 : void *argp1 = 0 ;
34799 : int res1 = 0 ;
34800 1 : void *argp2 = 0 ;
34801 : int res2 = 0 ;
34802 : int val3 ;
34803 : int ecode3 = 0 ;
34804 : double val4 ;
34805 : int ecode4 = 0 ;
34806 1 : PyObject * obj0 = 0 ;
34807 1 : PyObject * obj1 = 0 ;
34808 1 : PyObject * obj2 = 0 ;
34809 1 : PyObject * obj3 = 0 ;
34810 : int result;
34811 :
34812 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_queryByPoint",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34813 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34814 1 : if (!SWIG_IsOK(res1)) {
34815 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByPoint" "', argument " "1"" of type '" "struct mapObj *""'");
34816 : }
34817 1 : arg1 = (struct mapObj *)(argp1);
34818 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
34819 1 : if (!SWIG_IsOK(res2)) {
34820 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByPoint" "', argument " "2"" of type '" "pointObj *""'");
34821 : }
34822 1 : arg2 = (pointObj *)(argp2);
34823 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
34824 1 : if (!SWIG_IsOK(ecode3)) {
34825 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_queryByPoint" "', argument " "3"" of type '" "int""'");
34826 : }
34827 : arg3 = (int)(val3);
34828 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
34829 1 : if (!SWIG_IsOK(ecode4)) {
34830 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_queryByPoint" "', argument " "4"" of type '" "double""'");
34831 : }
34832 1 : arg4 = (double)(val4);
34833 : {
34834 : result = (int)mapObj_queryByPoint(arg1,arg2,arg3,arg4); {
34835 1 : errorObj *ms_error = msGetErrorObj();
34836 :
34837 1 : switch(ms_error->code) {
34838 : case MS_NOERR:
34839 : break;
34840 0 : case MS_NOTFOUND:
34841 0 : msResetErrorList();
34842 0 : break;
34843 : case -1:
34844 : break;
34845 0 : case MS_IOERR:
34846 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34847 0 : _raise_ms_exception();
34848 0 : msResetErrorList();
34849 0 : return NULL;
34850 : }
34851 : default:
34852 0 : _raise_ms_exception();
34853 0 : msResetErrorList();
34854 0 : return NULL;
34855 : }
34856 :
34857 : }
34858 : }
34859 : resultobj = SWIG_From_int((int)(result));
34860 1 : return resultobj;
34861 0 : fail:
34862 : return NULL;
34863 : }
34864 :
34865 :
34866 0 : SWIGINTERN PyObject *_wrap_mapObj_queryByRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34867 : PyObject *resultobj = 0;
34868 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34869 : rectObj arg2 ;
34870 0 : void *argp1 = 0 ;
34871 : int res1 = 0 ;
34872 : void *argp2 ;
34873 : int res2 = 0 ;
34874 0 : PyObject * obj0 = 0 ;
34875 0 : PyObject * obj1 = 0 ;
34876 : int result;
34877 :
34878 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByRect",&obj0,&obj1)) SWIG_fail;
34879 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34880 0 : if (!SWIG_IsOK(res1)) {
34881 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByRect" "', argument " "1"" of type '" "struct mapObj *""'");
34882 : }
34883 0 : arg1 = (struct mapObj *)(argp1);
34884 : {
34885 0 : res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_rectObj, 0 );
34886 0 : if (!SWIG_IsOK(res2)) {
34887 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByRect" "', argument " "2"" of type '" "rectObj""'");
34888 : }
34889 0 : if (!argp2) {
34890 : SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "mapObj_queryByRect" "', argument " "2"" of type '" "rectObj""'");
34891 : } else {
34892 0 : arg2 = *((rectObj *)(argp2));
34893 : }
34894 : }
34895 : {
34896 : result = (int)mapObj_queryByRect(arg1,arg2); {
34897 0 : errorObj *ms_error = msGetErrorObj();
34898 :
34899 0 : switch(ms_error->code) {
34900 : case MS_NOERR:
34901 : break;
34902 0 : case MS_NOTFOUND:
34903 0 : msResetErrorList();
34904 0 : break;
34905 : case -1:
34906 : break;
34907 0 : case MS_IOERR:
34908 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34909 0 : _raise_ms_exception();
34910 0 : msResetErrorList();
34911 0 : return NULL;
34912 : }
34913 : default:
34914 0 : _raise_ms_exception();
34915 0 : msResetErrorList();
34916 0 : return NULL;
34917 : }
34918 :
34919 : }
34920 : }
34921 : resultobj = SWIG_From_int((int)(result));
34922 0 : return resultobj;
34923 0 : fail:
34924 : return NULL;
34925 : }
34926 :
34927 :
34928 0 : SWIGINTERN PyObject *_wrap_mapObj_queryByFeatures(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34929 : PyObject *resultobj = 0;
34930 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34931 : int arg2 ;
34932 0 : void *argp1 = 0 ;
34933 : int res1 = 0 ;
34934 : int val2 ;
34935 : int ecode2 = 0 ;
34936 0 : PyObject * obj0 = 0 ;
34937 0 : PyObject * obj1 = 0 ;
34938 : int result;
34939 :
34940 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByFeatures",&obj0,&obj1)) SWIG_fail;
34941 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34942 0 : if (!SWIG_IsOK(res1)) {
34943 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByFeatures" "', argument " "1"" of type '" "struct mapObj *""'");
34944 : }
34945 0 : arg1 = (struct mapObj *)(argp1);
34946 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34947 0 : if (!SWIG_IsOK(ecode2)) {
34948 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_queryByFeatures" "', argument " "2"" of type '" "int""'");
34949 : }
34950 : arg2 = (int)(val2);
34951 : {
34952 : result = (int)mapObj_queryByFeatures(arg1,arg2); {
34953 0 : errorObj *ms_error = msGetErrorObj();
34954 :
34955 0 : switch(ms_error->code) {
34956 : case MS_NOERR:
34957 : break;
34958 0 : case MS_NOTFOUND:
34959 0 : msResetErrorList();
34960 0 : break;
34961 : case -1:
34962 : break;
34963 0 : case MS_IOERR:
34964 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
34965 0 : _raise_ms_exception();
34966 0 : msResetErrorList();
34967 0 : return NULL;
34968 : }
34969 : default:
34970 0 : _raise_ms_exception();
34971 0 : msResetErrorList();
34972 0 : return NULL;
34973 : }
34974 :
34975 : }
34976 : }
34977 : resultobj = SWIG_From_int((int)(result));
34978 0 : return resultobj;
34979 0 : fail:
34980 : return NULL;
34981 : }
34982 :
34983 :
34984 0 : SWIGINTERN PyObject *_wrap_mapObj_queryByShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34985 : PyObject *resultobj = 0;
34986 : struct mapObj *arg1 = (struct mapObj *) 0 ;
34987 : shapeObj *arg2 = (shapeObj *) 0 ;
34988 0 : void *argp1 = 0 ;
34989 : int res1 = 0 ;
34990 0 : void *argp2 = 0 ;
34991 : int res2 = 0 ;
34992 0 : PyObject * obj0 = 0 ;
34993 0 : PyObject * obj1 = 0 ;
34994 : int result;
34995 :
34996 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_queryByShape",&obj0,&obj1)) SWIG_fail;
34997 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
34998 0 : if (!SWIG_IsOK(res1)) {
34999 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_queryByShape" "', argument " "1"" of type '" "struct mapObj *""'");
35000 : }
35001 0 : arg1 = (struct mapObj *)(argp1);
35002 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
35003 0 : if (!SWIG_IsOK(res2)) {
35004 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_queryByShape" "', argument " "2"" of type '" "shapeObj *""'");
35005 : }
35006 0 : arg2 = (shapeObj *)(argp2);
35007 : {
35008 0 : result = (int)mapObj_queryByShape(arg1,arg2); {
35009 0 : errorObj *ms_error = msGetErrorObj();
35010 :
35011 0 : switch(ms_error->code) {
35012 : case MS_NOERR:
35013 : break;
35014 0 : case MS_NOTFOUND:
35015 0 : msResetErrorList();
35016 0 : break;
35017 : case -1:
35018 : break;
35019 0 : case MS_IOERR:
35020 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35021 0 : _raise_ms_exception();
35022 0 : msResetErrorList();
35023 0 : return NULL;
35024 : }
35025 : default:
35026 0 : _raise_ms_exception();
35027 0 : msResetErrorList();
35028 0 : return NULL;
35029 : }
35030 :
35031 : }
35032 : }
35033 : resultobj = SWIG_From_int((int)(result));
35034 0 : return resultobj;
35035 0 : fail:
35036 : return NULL;
35037 : }
35038 :
35039 :
35040 1 : SWIGINTERN PyObject *_wrap_mapObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35041 : PyObject *resultobj = 0;
35042 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35043 : char *arg2 = (char *) 0 ;
35044 1 : void *argp1 = 0 ;
35045 : int res1 = 0 ;
35046 : int res2 ;
35047 1 : char *buf2 = 0 ;
35048 1 : int alloc2 = 0 ;
35049 1 : PyObject * obj0 = 0 ;
35050 1 : PyObject * obj1 = 0 ;
35051 : int result;
35052 :
35053 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
35054 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35055 1 : if (!SWIG_IsOK(res1)) {
35056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setWKTProjection" "', argument " "1"" of type '" "struct mapObj *""'");
35057 : }
35058 1 : arg1 = (struct mapObj *)(argp1);
35059 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35060 1 : if (!SWIG_IsOK(res2)) {
35061 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
35062 : }
35063 1 : arg2 = (char *)(buf2);
35064 : {
35065 : result = (int)mapObj_setWKTProjection(arg1,arg2); {
35066 1 : errorObj *ms_error = msGetErrorObj();
35067 :
35068 1 : switch(ms_error->code) {
35069 : case MS_NOERR:
35070 : break;
35071 0 : case MS_NOTFOUND:
35072 0 : msResetErrorList();
35073 0 : break;
35074 : case -1:
35075 : break;
35076 0 : case MS_IOERR:
35077 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35078 0 : _raise_ms_exception();
35079 0 : msResetErrorList();
35080 0 : return NULL;
35081 : }
35082 : default:
35083 0 : _raise_ms_exception();
35084 0 : msResetErrorList();
35085 0 : return NULL;
35086 : }
35087 :
35088 : }
35089 : }
35090 : resultobj = SWIG_From_int((int)(result));
35091 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35092 : return resultobj;
35093 0 : fail:
35094 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35095 : return NULL;
35096 : }
35097 :
35098 :
35099 1 : SWIGINTERN PyObject *_wrap_mapObj_getProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35100 : PyObject *resultobj = 0;
35101 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35102 1 : void *argp1 = 0 ;
35103 : int res1 = 0 ;
35104 1 : PyObject * obj0 = 0 ;
35105 : char *result = 0 ;
35106 :
35107 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getProjection",&obj0)) SWIG_fail;
35108 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35109 1 : if (!SWIG_IsOK(res1)) {
35110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getProjection" "', argument " "1"" of type '" "struct mapObj *""'");
35111 : }
35112 1 : arg1 = (struct mapObj *)(argp1);
35113 : {
35114 : result = (char *)mapObj_getProjection(arg1); {
35115 1 : errorObj *ms_error = msGetErrorObj();
35116 :
35117 1 : switch(ms_error->code) {
35118 : case MS_NOERR:
35119 : break;
35120 0 : case MS_NOTFOUND:
35121 0 : msResetErrorList();
35122 0 : break;
35123 : case -1:
35124 : break;
35125 0 : case MS_IOERR:
35126 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35127 0 : _raise_ms_exception();
35128 0 : msResetErrorList();
35129 0 : return NULL;
35130 : }
35131 : default:
35132 0 : _raise_ms_exception();
35133 0 : msResetErrorList();
35134 0 : return NULL;
35135 : }
35136 :
35137 : }
35138 : }
35139 1 : resultobj = SWIG_FromCharPtr((const char *)result);
35140 1 : free((char*)result);
35141 1 : return resultobj;
35142 0 : fail:
35143 : return NULL;
35144 : }
35145 :
35146 :
35147 1 : SWIGINTERN PyObject *_wrap_mapObj_setProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35148 : PyObject *resultobj = 0;
35149 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35150 : char *arg2 = (char *) 0 ;
35151 1 : void *argp1 = 0 ;
35152 : int res1 = 0 ;
35153 : int res2 ;
35154 1 : char *buf2 = 0 ;
35155 1 : int alloc2 = 0 ;
35156 1 : PyObject * obj0 = 0 ;
35157 1 : PyObject * obj1 = 0 ;
35158 : int result;
35159 :
35160 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setProjection",&obj0,&obj1)) SWIG_fail;
35161 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35162 1 : if (!SWIG_IsOK(res1)) {
35163 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setProjection" "', argument " "1"" of type '" "struct mapObj *""'");
35164 : }
35165 1 : arg1 = (struct mapObj *)(argp1);
35166 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35167 1 : if (!SWIG_IsOK(res2)) {
35168 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setProjection" "', argument " "2"" of type '" "char *""'");
35169 : }
35170 1 : arg2 = (char *)(buf2);
35171 : {
35172 : result = (int)mapObj_setProjection(arg1,arg2); {
35173 1 : errorObj *ms_error = msGetErrorObj();
35174 :
35175 1 : switch(ms_error->code) {
35176 : case MS_NOERR:
35177 : break;
35178 0 : case MS_NOTFOUND:
35179 0 : msResetErrorList();
35180 0 : break;
35181 : case -1:
35182 : break;
35183 0 : case MS_IOERR:
35184 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35185 0 : _raise_ms_exception();
35186 0 : msResetErrorList();
35187 0 : return NULL;
35188 : }
35189 : default:
35190 0 : _raise_ms_exception();
35191 0 : msResetErrorList();
35192 0 : return NULL;
35193 : }
35194 :
35195 : }
35196 : }
35197 : resultobj = SWIG_From_int((int)(result));
35198 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35199 : return resultobj;
35200 0 : fail:
35201 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35202 : return NULL;
35203 : }
35204 :
35205 :
35206 1 : SWIGINTERN PyObject *_wrap_mapObj_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35207 : PyObject *resultobj = 0;
35208 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35209 : char *arg2 = (char *) 0 ;
35210 1 : void *argp1 = 0 ;
35211 : int res1 = 0 ;
35212 : int res2 ;
35213 1 : char *buf2 = 0 ;
35214 1 : int alloc2 = 0 ;
35215 1 : PyObject * obj0 = 0 ;
35216 1 : PyObject * obj1 = 0 ;
35217 : int result;
35218 :
35219 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_save",&obj0,&obj1)) SWIG_fail;
35220 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35221 1 : if (!SWIG_IsOK(res1)) {
35222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_save" "', argument " "1"" of type '" "struct mapObj *""'");
35223 : }
35224 1 : arg1 = (struct mapObj *)(argp1);
35225 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35226 1 : if (!SWIG_IsOK(res2)) {
35227 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_save" "', argument " "2"" of type '" "char *""'");
35228 : }
35229 1 : arg2 = (char *)(buf2);
35230 : {
35231 : result = (int)mapObj_save(arg1,arg2); {
35232 1 : errorObj *ms_error = msGetErrorObj();
35233 :
35234 1 : switch(ms_error->code) {
35235 : case MS_NOERR:
35236 : break;
35237 0 : case MS_NOTFOUND:
35238 0 : msResetErrorList();
35239 0 : break;
35240 : case -1:
35241 : break;
35242 0 : case MS_IOERR:
35243 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35244 0 : _raise_ms_exception();
35245 0 : msResetErrorList();
35246 0 : return NULL;
35247 : }
35248 : default:
35249 0 : _raise_ms_exception();
35250 0 : msResetErrorList();
35251 0 : return NULL;
35252 : }
35253 :
35254 : }
35255 : }
35256 : resultobj = SWIG_From_int((int)(result));
35257 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35258 : return resultobj;
35259 0 : fail:
35260 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35261 : return NULL;
35262 : }
35263 :
35264 :
35265 1 : SWIGINTERN PyObject *_wrap_mapObj_saveQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35266 : PyObject *resultobj = 0;
35267 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35268 : char *arg2 = (char *) 0 ;
35269 : int arg3 = (int) 0 ;
35270 1 : void *argp1 = 0 ;
35271 : int res1 = 0 ;
35272 : int res2 ;
35273 1 : char *buf2 = 0 ;
35274 1 : int alloc2 = 0 ;
35275 : int val3 ;
35276 : int ecode3 = 0 ;
35277 1 : PyObject * obj0 = 0 ;
35278 1 : PyObject * obj1 = 0 ;
35279 1 : PyObject * obj2 = 0 ;
35280 : int result;
35281 :
35282 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_saveQuery",&obj0,&obj1,&obj2)) SWIG_fail;
35283 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35284 1 : if (!SWIG_IsOK(res1)) {
35285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveQuery" "', argument " "1"" of type '" "struct mapObj *""'");
35286 : }
35287 1 : arg1 = (struct mapObj *)(argp1);
35288 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35289 1 : if (!SWIG_IsOK(res2)) {
35290 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveQuery" "', argument " "2"" of type '" "char *""'");
35291 : }
35292 1 : arg2 = (char *)(buf2);
35293 1 : if (obj2) {
35294 : ecode3 = SWIG_AsVal_int(obj2, &val3);
35295 1 : if (!SWIG_IsOK(ecode3)) {
35296 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_saveQuery" "', argument " "3"" of type '" "int""'");
35297 : }
35298 : arg3 = (int)(val3);
35299 : }
35300 : {
35301 : result = (int)mapObj_saveQuery(arg1,arg2,arg3); {
35302 1 : errorObj *ms_error = msGetErrorObj();
35303 :
35304 1 : switch(ms_error->code) {
35305 : case MS_NOERR:
35306 : break;
35307 0 : case MS_NOTFOUND:
35308 0 : msResetErrorList();
35309 0 : break;
35310 : case -1:
35311 : break;
35312 0 : case MS_IOERR:
35313 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35314 0 : _raise_ms_exception();
35315 0 : msResetErrorList();
35316 0 : return NULL;
35317 : }
35318 : default:
35319 0 : _raise_ms_exception();
35320 0 : msResetErrorList();
35321 0 : return NULL;
35322 : }
35323 :
35324 : }
35325 : }
35326 : resultobj = SWIG_From_int((int)(result));
35327 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35328 : return resultobj;
35329 0 : fail:
35330 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35331 : return NULL;
35332 : }
35333 :
35334 :
35335 1 : SWIGINTERN PyObject *_wrap_mapObj_loadQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35336 : PyObject *resultobj = 0;
35337 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35338 : char *arg2 = (char *) 0 ;
35339 1 : void *argp1 = 0 ;
35340 : int res1 = 0 ;
35341 : int res2 ;
35342 1 : char *buf2 = 0 ;
35343 1 : int alloc2 = 0 ;
35344 1 : PyObject * obj0 = 0 ;
35345 1 : PyObject * obj1 = 0 ;
35346 : int result;
35347 :
35348 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_loadQuery",&obj0,&obj1)) SWIG_fail;
35349 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35350 1 : if (!SWIG_IsOK(res1)) {
35351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadQuery" "', argument " "1"" of type '" "struct mapObj *""'");
35352 : }
35353 1 : arg1 = (struct mapObj *)(argp1);
35354 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35355 1 : if (!SWIG_IsOK(res2)) {
35356 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadQuery" "', argument " "2"" of type '" "char *""'");
35357 : }
35358 1 : arg2 = (char *)(buf2);
35359 : {
35360 : result = (int)mapObj_loadQuery(arg1,arg2); {
35361 1 : errorObj *ms_error = msGetErrorObj();
35362 :
35363 1 : switch(ms_error->code) {
35364 : case MS_NOERR:
35365 : break;
35366 0 : case MS_NOTFOUND:
35367 0 : msResetErrorList();
35368 0 : break;
35369 : case -1:
35370 : break;
35371 0 : case MS_IOERR:
35372 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35373 0 : _raise_ms_exception();
35374 0 : msResetErrorList();
35375 0 : return NULL;
35376 : }
35377 : default:
35378 0 : _raise_ms_exception();
35379 0 : msResetErrorList();
35380 0 : return NULL;
35381 : }
35382 :
35383 : }
35384 : }
35385 : resultobj = SWIG_From_int((int)(result));
35386 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35387 : return resultobj;
35388 0 : fail:
35389 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35390 : return NULL;
35391 : }
35392 :
35393 :
35394 1 : SWIGINTERN PyObject *_wrap_mapObj_freeQuery(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35395 : PyObject *resultobj = 0;
35396 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35397 : int arg2 = (int) -1 ;
35398 1 : void *argp1 = 0 ;
35399 : int res1 = 0 ;
35400 : int val2 ;
35401 : int ecode2 = 0 ;
35402 1 : PyObject * obj0 = 0 ;
35403 1 : PyObject * obj1 = 0 ;
35404 :
35405 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_freeQuery",&obj0,&obj1)) SWIG_fail;
35406 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35407 1 : if (!SWIG_IsOK(res1)) {
35408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_freeQuery" "', argument " "1"" of type '" "struct mapObj *""'");
35409 : }
35410 1 : arg1 = (struct mapObj *)(argp1);
35411 1 : if (obj1) {
35412 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35413 1 : if (!SWIG_IsOK(ecode2)) {
35414 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_freeQuery" "', argument " "2"" of type '" "int""'");
35415 : }
35416 : arg2 = (int)(val2);
35417 : }
35418 : {
35419 : mapObj_freeQuery(arg1,arg2); {
35420 1 : errorObj *ms_error = msGetErrorObj();
35421 :
35422 1 : switch(ms_error->code) {
35423 : case MS_NOERR:
35424 : break;
35425 0 : case MS_NOTFOUND:
35426 0 : msResetErrorList();
35427 0 : break;
35428 : case -1:
35429 : break;
35430 0 : case MS_IOERR:
35431 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35432 0 : _raise_ms_exception();
35433 0 : msResetErrorList();
35434 0 : return NULL;
35435 : }
35436 : default:
35437 0 : _raise_ms_exception();
35438 0 : msResetErrorList();
35439 0 : return NULL;
35440 : }
35441 :
35442 : }
35443 : }
35444 : resultobj = SWIG_Py_Void();
35445 1 : return resultobj;
35446 0 : fail:
35447 : return NULL;
35448 : }
35449 :
35450 :
35451 0 : SWIGINTERN PyObject *_wrap_mapObj_saveQueryAsGML(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35452 : PyObject *resultobj = 0;
35453 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35454 : char *arg2 = (char *) 0 ;
35455 : char *arg3 = (char *) "GOMF" ;
35456 0 : void *argp1 = 0 ;
35457 : int res1 = 0 ;
35458 : int res2 ;
35459 0 : char *buf2 = 0 ;
35460 0 : int alloc2 = 0 ;
35461 : int res3 ;
35462 0 : char *buf3 = 0 ;
35463 0 : int alloc3 = 0 ;
35464 0 : PyObject * obj0 = 0 ;
35465 0 : PyObject * obj1 = 0 ;
35466 0 : PyObject * obj2 = 0 ;
35467 : int result;
35468 :
35469 0 : if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_saveQueryAsGML",&obj0,&obj1,&obj2)) SWIG_fail;
35470 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35471 0 : if (!SWIG_IsOK(res1)) {
35472 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveQueryAsGML" "', argument " "1"" of type '" "struct mapObj *""'");
35473 : }
35474 0 : arg1 = (struct mapObj *)(argp1);
35475 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35476 0 : if (!SWIG_IsOK(res2)) {
35477 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveQueryAsGML" "', argument " "2"" of type '" "char *""'");
35478 : }
35479 0 : arg2 = (char *)(buf2);
35480 0 : if (obj2) {
35481 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
35482 0 : if (!SWIG_IsOK(res3)) {
35483 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_saveQueryAsGML" "', argument " "3"" of type '" "char const *""'");
35484 : }
35485 0 : arg3 = (char *)(buf3);
35486 : }
35487 : {
35488 : result = (int)mapObj_saveQueryAsGML(arg1,arg2,(char const *)arg3); {
35489 0 : errorObj *ms_error = msGetErrorObj();
35490 :
35491 0 : switch(ms_error->code) {
35492 : case MS_NOERR:
35493 : break;
35494 0 : case MS_NOTFOUND:
35495 0 : msResetErrorList();
35496 0 : break;
35497 : case -1:
35498 : break;
35499 0 : case MS_IOERR:
35500 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35501 0 : _raise_ms_exception();
35502 0 : msResetErrorList();
35503 0 : return NULL;
35504 : }
35505 : default:
35506 0 : _raise_ms_exception();
35507 0 : msResetErrorList();
35508 0 : return NULL;
35509 : }
35510 :
35511 : }
35512 : }
35513 : resultobj = SWIG_From_int((int)(result));
35514 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35515 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
35516 : return resultobj;
35517 0 : fail:
35518 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35519 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
35520 : return NULL;
35521 : }
35522 :
35523 :
35524 1 : SWIGINTERN PyObject *_wrap_mapObj_getMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35525 : PyObject *resultobj = 0;
35526 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35527 : char *arg2 = (char *) 0 ;
35528 1 : void *argp1 = 0 ;
35529 : int res1 = 0 ;
35530 : int res2 ;
35531 1 : char *buf2 = 0 ;
35532 1 : int alloc2 = 0 ;
35533 1 : PyObject * obj0 = 0 ;
35534 1 : PyObject * obj1 = 0 ;
35535 : char *result = 0 ;
35536 :
35537 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getMetaData",&obj0,&obj1)) SWIG_fail;
35538 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35539 1 : if (!SWIG_IsOK(res1)) {
35540 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getMetaData" "', argument " "1"" of type '" "struct mapObj *""'");
35541 : }
35542 1 : arg1 = (struct mapObj *)(argp1);
35543 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35544 1 : if (!SWIG_IsOK(res2)) {
35545 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getMetaData" "', argument " "2"" of type '" "char *""'");
35546 : }
35547 1 : arg2 = (char *)(buf2);
35548 : {
35549 1 : result = (char *)mapObj_getMetaData(arg1,arg2); {
35550 1 : errorObj *ms_error = msGetErrorObj();
35551 :
35552 1 : switch(ms_error->code) {
35553 : case MS_NOERR:
35554 : break;
35555 0 : case MS_NOTFOUND:
35556 0 : msResetErrorList();
35557 0 : break;
35558 : case -1:
35559 : break;
35560 0 : case MS_IOERR:
35561 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35562 0 : _raise_ms_exception();
35563 0 : msResetErrorList();
35564 0 : return NULL;
35565 : }
35566 : default:
35567 1 : _raise_ms_exception();
35568 1 : msResetErrorList();
35569 1 : return NULL;
35570 : }
35571 :
35572 : }
35573 : }
35574 1 : resultobj = SWIG_FromCharPtr((const char *)result);
35575 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35576 : return resultobj;
35577 0 : fail:
35578 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35579 : return NULL;
35580 : }
35581 :
35582 :
35583 1 : SWIGINTERN PyObject *_wrap_mapObj_setMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35584 : PyObject *resultobj = 0;
35585 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35586 : char *arg2 = (char *) 0 ;
35587 : char *arg3 = (char *) 0 ;
35588 1 : void *argp1 = 0 ;
35589 : int res1 = 0 ;
35590 : int res2 ;
35591 1 : char *buf2 = 0 ;
35592 1 : int alloc2 = 0 ;
35593 : int res3 ;
35594 1 : char *buf3 = 0 ;
35595 1 : int alloc3 = 0 ;
35596 1 : PyObject * obj0 = 0 ;
35597 1 : PyObject * obj1 = 0 ;
35598 1 : PyObject * obj2 = 0 ;
35599 : int result;
35600 :
35601 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setMetaData",&obj0,&obj1,&obj2)) SWIG_fail;
35602 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35603 1 : if (!SWIG_IsOK(res1)) {
35604 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setMetaData" "', argument " "1"" of type '" "struct mapObj *""'");
35605 : }
35606 1 : arg1 = (struct mapObj *)(argp1);
35607 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35608 1 : if (!SWIG_IsOK(res2)) {
35609 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setMetaData" "', argument " "2"" of type '" "char *""'");
35610 : }
35611 1 : arg2 = (char *)(buf2);
35612 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
35613 1 : if (!SWIG_IsOK(res3)) {
35614 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_setMetaData" "', argument " "3"" of type '" "char *""'");
35615 : }
35616 1 : arg3 = (char *)(buf3);
35617 : {
35618 : result = (int)mapObj_setMetaData(arg1,arg2,arg3); {
35619 1 : errorObj *ms_error = msGetErrorObj();
35620 :
35621 1 : switch(ms_error->code) {
35622 : case MS_NOERR:
35623 : break;
35624 0 : case MS_NOTFOUND:
35625 0 : msResetErrorList();
35626 0 : break;
35627 : case -1:
35628 : break;
35629 0 : case MS_IOERR:
35630 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35631 0 : _raise_ms_exception();
35632 0 : msResetErrorList();
35633 0 : return NULL;
35634 : }
35635 : default:
35636 0 : _raise_ms_exception();
35637 0 : msResetErrorList();
35638 0 : return NULL;
35639 : }
35640 :
35641 : }
35642 : }
35643 : resultobj = SWIG_From_int((int)(result));
35644 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35645 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
35646 : return resultobj;
35647 0 : fail:
35648 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35649 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
35650 : return NULL;
35651 : }
35652 :
35653 :
35654 0 : SWIGINTERN PyObject *_wrap_mapObj_removeMetaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35655 : PyObject *resultobj = 0;
35656 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35657 : char *arg2 = (char *) 0 ;
35658 0 : void *argp1 = 0 ;
35659 : int res1 = 0 ;
35660 : int res2 ;
35661 0 : char *buf2 = 0 ;
35662 0 : int alloc2 = 0 ;
35663 0 : PyObject * obj0 = 0 ;
35664 0 : PyObject * obj1 = 0 ;
35665 : int result;
35666 :
35667 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeMetaData",&obj0,&obj1)) SWIG_fail;
35668 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35669 0 : if (!SWIG_IsOK(res1)) {
35670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeMetaData" "', argument " "1"" of type '" "struct mapObj *""'");
35671 : }
35672 0 : arg1 = (struct mapObj *)(argp1);
35673 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35674 0 : if (!SWIG_IsOK(res2)) {
35675 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_removeMetaData" "', argument " "2"" of type '" "char *""'");
35676 : }
35677 0 : arg2 = (char *)(buf2);
35678 : {
35679 : result = (int)mapObj_removeMetaData(arg1,arg2); {
35680 0 : errorObj *ms_error = msGetErrorObj();
35681 :
35682 0 : switch(ms_error->code) {
35683 : case MS_NOERR:
35684 : break;
35685 0 : case MS_NOTFOUND:
35686 0 : msResetErrorList();
35687 0 : break;
35688 : case -1:
35689 : break;
35690 0 : case MS_IOERR:
35691 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35692 0 : _raise_ms_exception();
35693 0 : msResetErrorList();
35694 0 : return NULL;
35695 : }
35696 : default:
35697 0 : _raise_ms_exception();
35698 0 : msResetErrorList();
35699 0 : return NULL;
35700 : }
35701 :
35702 : }
35703 : }
35704 : resultobj = SWIG_From_int((int)(result));
35705 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35706 : return resultobj;
35707 0 : fail:
35708 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35709 : return NULL;
35710 : }
35711 :
35712 :
35713 1 : SWIGINTERN PyObject *_wrap_mapObj_getFirstMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35714 : PyObject *resultobj = 0;
35715 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35716 1 : void *argp1 = 0 ;
35717 : int res1 = 0 ;
35718 1 : PyObject * obj0 = 0 ;
35719 : char *result = 0 ;
35720 :
35721 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getFirstMetaDataKey",&obj0)) SWIG_fail;
35722 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35723 1 : if (!SWIG_IsOK(res1)) {
35724 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getFirstMetaDataKey" "', argument " "1"" of type '" "struct mapObj *""'");
35725 : }
35726 1 : arg1 = (struct mapObj *)(argp1);
35727 : {
35728 : result = (char *)mapObj_getFirstMetaDataKey(arg1); {
35729 1 : errorObj *ms_error = msGetErrorObj();
35730 :
35731 1 : switch(ms_error->code) {
35732 : case MS_NOERR:
35733 : break;
35734 0 : case MS_NOTFOUND:
35735 0 : msResetErrorList();
35736 0 : break;
35737 : case -1:
35738 : break;
35739 0 : case MS_IOERR:
35740 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35741 0 : _raise_ms_exception();
35742 0 : msResetErrorList();
35743 0 : return NULL;
35744 : }
35745 : default:
35746 0 : _raise_ms_exception();
35747 0 : msResetErrorList();
35748 0 : return NULL;
35749 : }
35750 :
35751 : }
35752 : }
35753 1 : resultobj = SWIG_FromCharPtr((const char *)result);
35754 1 : return resultobj;
35755 0 : fail:
35756 : return NULL;
35757 : }
35758 :
35759 :
35760 1 : SWIGINTERN PyObject *_wrap_mapObj_getNextMetaDataKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35761 : PyObject *resultobj = 0;
35762 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35763 : char *arg2 = (char *) 0 ;
35764 1 : void *argp1 = 0 ;
35765 : int res1 = 0 ;
35766 : int res2 ;
35767 1 : char *buf2 = 0 ;
35768 1 : int alloc2 = 0 ;
35769 1 : PyObject * obj0 = 0 ;
35770 1 : PyObject * obj1 = 0 ;
35771 : char *result = 0 ;
35772 :
35773 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getNextMetaDataKey",&obj0,&obj1)) SWIG_fail;
35774 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35775 1 : if (!SWIG_IsOK(res1)) {
35776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getNextMetaDataKey" "', argument " "1"" of type '" "struct mapObj *""'");
35777 : }
35778 1 : arg1 = (struct mapObj *)(argp1);
35779 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35780 1 : if (!SWIG_IsOK(res2)) {
35781 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getNextMetaDataKey" "', argument " "2"" of type '" "char *""'");
35782 : }
35783 1 : arg2 = (char *)(buf2);
35784 : {
35785 : result = (char *)mapObj_getNextMetaDataKey(arg1,arg2); {
35786 1 : errorObj *ms_error = msGetErrorObj();
35787 :
35788 1 : switch(ms_error->code) {
35789 : case MS_NOERR:
35790 : break;
35791 0 : case MS_NOTFOUND:
35792 0 : msResetErrorList();
35793 0 : break;
35794 : case -1:
35795 : break;
35796 0 : case MS_IOERR:
35797 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35798 0 : _raise_ms_exception();
35799 0 : msResetErrorList();
35800 0 : return NULL;
35801 : }
35802 : default:
35803 0 : _raise_ms_exception();
35804 0 : msResetErrorList();
35805 0 : return NULL;
35806 : }
35807 :
35808 : }
35809 : }
35810 1 : resultobj = SWIG_FromCharPtr((const char *)result);
35811 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35812 : return resultobj;
35813 0 : fail:
35814 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35815 : return NULL;
35816 : }
35817 :
35818 :
35819 0 : SWIGINTERN PyObject *_wrap_mapObj_setSymbolSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35820 : PyObject *resultobj = 0;
35821 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35822 : char *arg2 = (char *) 0 ;
35823 0 : void *argp1 = 0 ;
35824 : int res1 = 0 ;
35825 : int res2 ;
35826 0 : char *buf2 = 0 ;
35827 0 : int alloc2 = 0 ;
35828 0 : PyObject * obj0 = 0 ;
35829 0 : PyObject * obj1 = 0 ;
35830 : int result;
35831 :
35832 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setSymbolSet",&obj0,&obj1)) SWIG_fail;
35833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35834 0 : if (!SWIG_IsOK(res1)) {
35835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setSymbolSet" "', argument " "1"" of type '" "struct mapObj *""'");
35836 : }
35837 0 : arg1 = (struct mapObj *)(argp1);
35838 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35839 0 : if (!SWIG_IsOK(res2)) {
35840 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setSymbolSet" "', argument " "2"" of type '" "char *""'");
35841 : }
35842 0 : arg2 = (char *)(buf2);
35843 : {
35844 0 : result = (int)mapObj_setSymbolSet(arg1,arg2); {
35845 0 : errorObj *ms_error = msGetErrorObj();
35846 :
35847 0 : switch(ms_error->code) {
35848 : case MS_NOERR:
35849 : break;
35850 0 : case MS_NOTFOUND:
35851 0 : msResetErrorList();
35852 0 : break;
35853 : case -1:
35854 : break;
35855 0 : case MS_IOERR:
35856 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35857 0 : _raise_ms_exception();
35858 0 : msResetErrorList();
35859 0 : return NULL;
35860 : }
35861 : default:
35862 0 : _raise_ms_exception();
35863 0 : msResetErrorList();
35864 0 : return NULL;
35865 : }
35866 :
35867 : }
35868 : }
35869 : resultobj = SWIG_From_int((int)(result));
35870 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35871 : return resultobj;
35872 0 : fail:
35873 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35874 : return NULL;
35875 : }
35876 :
35877 :
35878 1 : SWIGINTERN PyObject *_wrap_mapObj_getNumSymbols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35879 : PyObject *resultobj = 0;
35880 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35881 1 : void *argp1 = 0 ;
35882 : int res1 = 0 ;
35883 1 : PyObject * obj0 = 0 ;
35884 : int result;
35885 :
35886 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getNumSymbols",&obj0)) SWIG_fail;
35887 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35888 1 : if (!SWIG_IsOK(res1)) {
35889 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getNumSymbols" "', argument " "1"" of type '" "struct mapObj *""'");
35890 : }
35891 1 : arg1 = (struct mapObj *)(argp1);
35892 : {
35893 1 : result = (int)mapObj_getNumSymbols(arg1); {
35894 1 : errorObj *ms_error = msGetErrorObj();
35895 :
35896 1 : switch(ms_error->code) {
35897 : case MS_NOERR:
35898 : break;
35899 0 : case MS_NOTFOUND:
35900 0 : msResetErrorList();
35901 0 : break;
35902 : case -1:
35903 : break;
35904 0 : case MS_IOERR:
35905 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35906 0 : _raise_ms_exception();
35907 0 : msResetErrorList();
35908 0 : return NULL;
35909 : }
35910 : default:
35911 0 : _raise_ms_exception();
35912 0 : msResetErrorList();
35913 0 : return NULL;
35914 : }
35915 :
35916 : }
35917 : }
35918 : resultobj = SWIG_From_int((int)(result));
35919 1 : return resultobj;
35920 0 : fail:
35921 : return NULL;
35922 : }
35923 :
35924 :
35925 0 : SWIGINTERN PyObject *_wrap_mapObj_setFontSet(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35926 : PyObject *resultobj = 0;
35927 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35928 : char *arg2 = (char *) 0 ;
35929 0 : void *argp1 = 0 ;
35930 : int res1 = 0 ;
35931 : int res2 ;
35932 0 : char *buf2 = 0 ;
35933 0 : int alloc2 = 0 ;
35934 0 : PyObject * obj0 = 0 ;
35935 0 : PyObject * obj1 = 0 ;
35936 : int result;
35937 :
35938 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setFontSet",&obj0,&obj1)) SWIG_fail;
35939 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35940 0 : if (!SWIG_IsOK(res1)) {
35941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setFontSet" "', argument " "1"" of type '" "struct mapObj *""'");
35942 : }
35943 0 : arg1 = (struct mapObj *)(argp1);
35944 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35945 0 : if (!SWIG_IsOK(res2)) {
35946 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setFontSet" "', argument " "2"" of type '" "char *""'");
35947 : }
35948 0 : arg2 = (char *)(buf2);
35949 : {
35950 0 : result = (int)mapObj_setFontSet(arg1,arg2); {
35951 0 : errorObj *ms_error = msGetErrorObj();
35952 :
35953 0 : switch(ms_error->code) {
35954 : case MS_NOERR:
35955 : break;
35956 0 : case MS_NOTFOUND:
35957 0 : msResetErrorList();
35958 0 : break;
35959 : case -1:
35960 : break;
35961 0 : case MS_IOERR:
35962 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
35963 0 : _raise_ms_exception();
35964 0 : msResetErrorList();
35965 0 : return NULL;
35966 : }
35967 : default:
35968 0 : _raise_ms_exception();
35969 0 : msResetErrorList();
35970 0 : return NULL;
35971 : }
35972 :
35973 : }
35974 : }
35975 : resultobj = SWIG_From_int((int)(result));
35976 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35977 : return resultobj;
35978 0 : fail:
35979 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35980 : return NULL;
35981 : }
35982 :
35983 :
35984 0 : SWIGINTERN PyObject *_wrap_mapObj_saveMapContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35985 : PyObject *resultobj = 0;
35986 : struct mapObj *arg1 = (struct mapObj *) 0 ;
35987 : char *arg2 = (char *) 0 ;
35988 0 : void *argp1 = 0 ;
35989 : int res1 = 0 ;
35990 : int res2 ;
35991 0 : char *buf2 = 0 ;
35992 0 : int alloc2 = 0 ;
35993 0 : PyObject * obj0 = 0 ;
35994 0 : PyObject * obj1 = 0 ;
35995 : int result;
35996 :
35997 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_saveMapContext",&obj0,&obj1)) SWIG_fail;
35998 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
35999 0 : if (!SWIG_IsOK(res1)) {
36000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_saveMapContext" "', argument " "1"" of type '" "struct mapObj *""'");
36001 : }
36002 0 : arg1 = (struct mapObj *)(argp1);
36003 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36004 0 : if (!SWIG_IsOK(res2)) {
36005 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_saveMapContext" "', argument " "2"" of type '" "char *""'");
36006 : }
36007 0 : arg2 = (char *)(buf2);
36008 : {
36009 : result = (int)mapObj_saveMapContext(arg1,arg2); {
36010 0 : errorObj *ms_error = msGetErrorObj();
36011 :
36012 0 : switch(ms_error->code) {
36013 : case MS_NOERR:
36014 : break;
36015 0 : case MS_NOTFOUND:
36016 0 : msResetErrorList();
36017 0 : break;
36018 : case -1:
36019 : break;
36020 0 : case MS_IOERR:
36021 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36022 0 : _raise_ms_exception();
36023 0 : msResetErrorList();
36024 0 : return NULL;
36025 : }
36026 : default:
36027 0 : _raise_ms_exception();
36028 0 : msResetErrorList();
36029 0 : return NULL;
36030 : }
36031 :
36032 : }
36033 : }
36034 : resultobj = SWIG_From_int((int)(result));
36035 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36036 : return resultobj;
36037 0 : fail:
36038 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36039 : return NULL;
36040 : }
36041 :
36042 :
36043 0 : SWIGINTERN PyObject *_wrap_mapObj_loadMapContext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36044 : PyObject *resultobj = 0;
36045 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36046 : char *arg2 = (char *) 0 ;
36047 : int arg3 = (int) 0 ;
36048 0 : void *argp1 = 0 ;
36049 : int res1 = 0 ;
36050 : int res2 ;
36051 0 : char *buf2 = 0 ;
36052 0 : int alloc2 = 0 ;
36053 : int val3 ;
36054 : int ecode3 = 0 ;
36055 0 : PyObject * obj0 = 0 ;
36056 0 : PyObject * obj1 = 0 ;
36057 0 : PyObject * obj2 = 0 ;
36058 : int result;
36059 :
36060 0 : if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_loadMapContext",&obj0,&obj1,&obj2)) SWIG_fail;
36061 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36062 0 : if (!SWIG_IsOK(res1)) {
36063 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadMapContext" "', argument " "1"" of type '" "struct mapObj *""'");
36064 : }
36065 0 : arg1 = (struct mapObj *)(argp1);
36066 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36067 0 : if (!SWIG_IsOK(res2)) {
36068 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadMapContext" "', argument " "2"" of type '" "char *""'");
36069 : }
36070 0 : arg2 = (char *)(buf2);
36071 0 : if (obj2) {
36072 : ecode3 = SWIG_AsVal_int(obj2, &val3);
36073 0 : if (!SWIG_IsOK(ecode3)) {
36074 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_loadMapContext" "', argument " "3"" of type '" "int""'");
36075 : }
36076 : arg3 = (int)(val3);
36077 : }
36078 : {
36079 : result = (int)mapObj_loadMapContext(arg1,arg2,arg3); {
36080 0 : errorObj *ms_error = msGetErrorObj();
36081 :
36082 0 : switch(ms_error->code) {
36083 : case MS_NOERR:
36084 : break;
36085 0 : case MS_NOTFOUND:
36086 0 : msResetErrorList();
36087 0 : break;
36088 : case -1:
36089 : break;
36090 0 : case MS_IOERR:
36091 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36092 0 : _raise_ms_exception();
36093 0 : msResetErrorList();
36094 0 : return NULL;
36095 : }
36096 : default:
36097 0 : _raise_ms_exception();
36098 0 : msResetErrorList();
36099 0 : return NULL;
36100 : }
36101 :
36102 : }
36103 : }
36104 : resultobj = SWIG_From_int((int)(result));
36105 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36106 : return resultobj;
36107 0 : fail:
36108 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36109 : return NULL;
36110 : }
36111 :
36112 :
36113 0 : SWIGINTERN PyObject *_wrap_mapObj_moveLayerUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36114 : PyObject *resultobj = 0;
36115 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36116 : int arg2 ;
36117 0 : void *argp1 = 0 ;
36118 : int res1 = 0 ;
36119 : int val2 ;
36120 : int ecode2 = 0 ;
36121 0 : PyObject * obj0 = 0 ;
36122 0 : PyObject * obj1 = 0 ;
36123 : int result;
36124 :
36125 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_moveLayerUp",&obj0,&obj1)) SWIG_fail;
36126 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36127 0 : if (!SWIG_IsOK(res1)) {
36128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_moveLayerUp" "', argument " "1"" of type '" "struct mapObj *""'");
36129 : }
36130 0 : arg1 = (struct mapObj *)(argp1);
36131 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
36132 0 : if (!SWIG_IsOK(ecode2)) {
36133 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_moveLayerUp" "', argument " "2"" of type '" "int""'");
36134 : }
36135 : arg2 = (int)(val2);
36136 : {
36137 : result = (int)mapObj_moveLayerUp(arg1,arg2); {
36138 0 : errorObj *ms_error = msGetErrorObj();
36139 :
36140 0 : switch(ms_error->code) {
36141 : case MS_NOERR:
36142 : break;
36143 0 : case MS_NOTFOUND:
36144 0 : msResetErrorList();
36145 0 : break;
36146 : case -1:
36147 : break;
36148 0 : case MS_IOERR:
36149 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36150 0 : _raise_ms_exception();
36151 0 : msResetErrorList();
36152 0 : return NULL;
36153 : }
36154 : default:
36155 0 : _raise_ms_exception();
36156 0 : msResetErrorList();
36157 0 : return NULL;
36158 : }
36159 :
36160 : }
36161 : }
36162 : resultobj = SWIG_From_int((int)(result));
36163 0 : return resultobj;
36164 0 : fail:
36165 : return NULL;
36166 : }
36167 :
36168 :
36169 0 : SWIGINTERN PyObject *_wrap_mapObj_moveLayerDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36170 : PyObject *resultobj = 0;
36171 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36172 : int arg2 ;
36173 0 : void *argp1 = 0 ;
36174 : int res1 = 0 ;
36175 : int val2 ;
36176 : int ecode2 = 0 ;
36177 0 : PyObject * obj0 = 0 ;
36178 0 : PyObject * obj1 = 0 ;
36179 : int result;
36180 :
36181 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_moveLayerDown",&obj0,&obj1)) SWIG_fail;
36182 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36183 0 : if (!SWIG_IsOK(res1)) {
36184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_moveLayerDown" "', argument " "1"" of type '" "struct mapObj *""'");
36185 : }
36186 0 : arg1 = (struct mapObj *)(argp1);
36187 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
36188 0 : if (!SWIG_IsOK(ecode2)) {
36189 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_moveLayerDown" "', argument " "2"" of type '" "int""'");
36190 : }
36191 : arg2 = (int)(val2);
36192 : {
36193 : result = (int)mapObj_moveLayerDown(arg1,arg2); {
36194 0 : errorObj *ms_error = msGetErrorObj();
36195 :
36196 0 : switch(ms_error->code) {
36197 : case MS_NOERR:
36198 : break;
36199 0 : case MS_NOTFOUND:
36200 0 : msResetErrorList();
36201 0 : break;
36202 : case -1:
36203 : break;
36204 0 : case MS_IOERR:
36205 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36206 0 : _raise_ms_exception();
36207 0 : msResetErrorList();
36208 0 : return NULL;
36209 : }
36210 : default:
36211 0 : _raise_ms_exception();
36212 0 : msResetErrorList();
36213 0 : return NULL;
36214 : }
36215 :
36216 : }
36217 : }
36218 : resultobj = SWIG_From_int((int)(result));
36219 0 : return resultobj;
36220 0 : fail:
36221 : return NULL;
36222 : }
36223 :
36224 :
36225 0 : SWIGINTERN PyObject *_wrap_mapObj_getLayersDrawingOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36226 : PyObject *resultobj = 0;
36227 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36228 0 : void *argp1 = 0 ;
36229 : int res1 = 0 ;
36230 0 : PyObject * obj0 = 0 ;
36231 : intarray *result = 0 ;
36232 :
36233 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getLayersDrawingOrder",&obj0)) SWIG_fail;
36234 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36235 0 : if (!SWIG_IsOK(res1)) {
36236 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayersDrawingOrder" "', argument " "1"" of type '" "struct mapObj *""'");
36237 : }
36238 0 : arg1 = (struct mapObj *)(argp1);
36239 : {
36240 0 : result = (intarray *)mapObj_getLayersDrawingOrder(arg1); {
36241 0 : errorObj *ms_error = msGetErrorObj();
36242 :
36243 0 : switch(ms_error->code) {
36244 : case MS_NOERR:
36245 : break;
36246 0 : case MS_NOTFOUND:
36247 0 : msResetErrorList();
36248 0 : break;
36249 : case -1:
36250 : break;
36251 0 : case MS_IOERR:
36252 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36253 0 : _raise_ms_exception();
36254 0 : msResetErrorList();
36255 0 : return NULL;
36256 : }
36257 : default:
36258 0 : _raise_ms_exception();
36259 0 : msResetErrorList();
36260 0 : return NULL;
36261 : }
36262 :
36263 : }
36264 : }
36265 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_intarray, SWIG_POINTER_OWN | 0 );
36266 0 : return resultobj;
36267 0 : fail:
36268 : return NULL;
36269 : }
36270 :
36271 :
36272 0 : SWIGINTERN PyObject *_wrap_mapObj_setLayersDrawingOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36273 : PyObject *resultobj = 0;
36274 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36275 : int *arg2 = (int *) 0 ;
36276 0 : void *argp1 = 0 ;
36277 : int res1 = 0 ;
36278 0 : void *argp2 = 0 ;
36279 : int res2 = 0 ;
36280 0 : PyObject * obj0 = 0 ;
36281 0 : PyObject * obj1 = 0 ;
36282 : int result;
36283 :
36284 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setLayersDrawingOrder",&obj0,&obj1)) SWIG_fail;
36285 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36286 0 : if (!SWIG_IsOK(res1)) {
36287 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setLayersDrawingOrder" "', argument " "1"" of type '" "struct mapObj *""'");
36288 : }
36289 0 : arg1 = (struct mapObj *)(argp1);
36290 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_int, 0 | 0 );
36291 0 : if (!SWIG_IsOK(res2)) {
36292 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setLayersDrawingOrder" "', argument " "2"" of type '" "int *""'");
36293 : }
36294 0 : arg2 = (int *)(argp2);
36295 : {
36296 : result = (int)mapObj_setLayersDrawingOrder(arg1,arg2); {
36297 0 : errorObj *ms_error = msGetErrorObj();
36298 :
36299 0 : switch(ms_error->code) {
36300 : case MS_NOERR:
36301 : break;
36302 0 : case MS_NOTFOUND:
36303 0 : msResetErrorList();
36304 0 : break;
36305 : case -1:
36306 : break;
36307 0 : case MS_IOERR:
36308 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36309 0 : _raise_ms_exception();
36310 0 : msResetErrorList();
36311 0 : return NULL;
36312 : }
36313 : default:
36314 0 : _raise_ms_exception();
36315 0 : msResetErrorList();
36316 0 : return NULL;
36317 : }
36318 :
36319 : }
36320 : }
36321 : resultobj = SWIG_From_int((int)(result));
36322 0 : return resultobj;
36323 0 : fail:
36324 : return NULL;
36325 : }
36326 :
36327 :
36328 0 : SWIGINTERN PyObject *_wrap_mapObj_setConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36329 : PyObject *resultobj = 0;
36330 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36331 : char *arg2 = (char *) 0 ;
36332 : char *arg3 = (char *) 0 ;
36333 0 : void *argp1 = 0 ;
36334 : int res1 = 0 ;
36335 : int res2 ;
36336 0 : char *buf2 = 0 ;
36337 0 : int alloc2 = 0 ;
36338 : int res3 ;
36339 0 : char *buf3 = 0 ;
36340 0 : int alloc3 = 0 ;
36341 0 : PyObject * obj0 = 0 ;
36342 0 : PyObject * obj1 = 0 ;
36343 0 : PyObject * obj2 = 0 ;
36344 :
36345 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:mapObj_setConfigOption",&obj0,&obj1,&obj2)) SWIG_fail;
36346 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36347 0 : if (!SWIG_IsOK(res1)) {
36348 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setConfigOption" "', argument " "1"" of type '" "struct mapObj *""'");
36349 : }
36350 0 : arg1 = (struct mapObj *)(argp1);
36351 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36352 0 : if (!SWIG_IsOK(res2)) {
36353 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_setConfigOption" "', argument " "2"" of type '" "char *""'");
36354 : }
36355 0 : arg2 = (char *)(buf2);
36356 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
36357 0 : if (!SWIG_IsOK(res3)) {
36358 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_setConfigOption" "', argument " "3"" of type '" "char *""'");
36359 : }
36360 0 : arg3 = (char *)(buf3);
36361 : {
36362 : mapObj_setConfigOption(arg1,arg2,arg3); {
36363 0 : errorObj *ms_error = msGetErrorObj();
36364 :
36365 0 : switch(ms_error->code) {
36366 : case MS_NOERR:
36367 : break;
36368 0 : case MS_NOTFOUND:
36369 0 : msResetErrorList();
36370 0 : break;
36371 : case -1:
36372 : break;
36373 0 : case MS_IOERR:
36374 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36375 0 : _raise_ms_exception();
36376 0 : msResetErrorList();
36377 0 : return NULL;
36378 : }
36379 : default:
36380 0 : _raise_ms_exception();
36381 0 : msResetErrorList();
36382 0 : return NULL;
36383 : }
36384 :
36385 : }
36386 : }
36387 : resultobj = SWIG_Py_Void();
36388 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36389 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
36390 : return resultobj;
36391 0 : fail:
36392 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36393 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
36394 : return NULL;
36395 : }
36396 :
36397 :
36398 0 : SWIGINTERN PyObject *_wrap_mapObj_getConfigOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36399 : PyObject *resultobj = 0;
36400 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36401 : char *arg2 = (char *) 0 ;
36402 0 : void *argp1 = 0 ;
36403 : int res1 = 0 ;
36404 : int res2 ;
36405 0 : char *buf2 = 0 ;
36406 0 : int alloc2 = 0 ;
36407 0 : PyObject * obj0 = 0 ;
36408 0 : PyObject * obj1 = 0 ;
36409 : char *result = 0 ;
36410 :
36411 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getConfigOption",&obj0,&obj1)) SWIG_fail;
36412 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36413 0 : if (!SWIG_IsOK(res1)) {
36414 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getConfigOption" "', argument " "1"" of type '" "struct mapObj *""'");
36415 : }
36416 0 : arg1 = (struct mapObj *)(argp1);
36417 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36418 0 : if (!SWIG_IsOK(res2)) {
36419 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getConfigOption" "', argument " "2"" of type '" "char *""'");
36420 : }
36421 0 : arg2 = (char *)(buf2);
36422 : {
36423 : result = (char *)mapObj_getConfigOption(arg1,arg2); {
36424 0 : errorObj *ms_error = msGetErrorObj();
36425 :
36426 0 : switch(ms_error->code) {
36427 : case MS_NOERR:
36428 : break;
36429 0 : case MS_NOTFOUND:
36430 0 : msResetErrorList();
36431 0 : break;
36432 : case -1:
36433 : break;
36434 0 : case MS_IOERR:
36435 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36436 0 : _raise_ms_exception();
36437 0 : msResetErrorList();
36438 0 : return NULL;
36439 : }
36440 : default:
36441 0 : _raise_ms_exception();
36442 0 : msResetErrorList();
36443 0 : return NULL;
36444 : }
36445 :
36446 : }
36447 : }
36448 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36449 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36450 : return resultobj;
36451 0 : fail:
36452 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36453 : return NULL;
36454 : }
36455 :
36456 :
36457 0 : SWIGINTERN PyObject *_wrap_mapObj_applyConfigOptions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36458 : PyObject *resultobj = 0;
36459 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36460 0 : void *argp1 = 0 ;
36461 : int res1 = 0 ;
36462 0 : PyObject * obj0 = 0 ;
36463 :
36464 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_applyConfigOptions",&obj0)) SWIG_fail;
36465 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36466 0 : if (!SWIG_IsOK(res1)) {
36467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applyConfigOptions" "', argument " "1"" of type '" "struct mapObj *""'");
36468 : }
36469 0 : arg1 = (struct mapObj *)(argp1);
36470 : {
36471 : mapObj_applyConfigOptions(arg1); {
36472 0 : errorObj *ms_error = msGetErrorObj();
36473 :
36474 0 : switch(ms_error->code) {
36475 : case MS_NOERR:
36476 : break;
36477 0 : case MS_NOTFOUND:
36478 0 : msResetErrorList();
36479 0 : break;
36480 : case -1:
36481 : break;
36482 0 : case MS_IOERR:
36483 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36484 0 : _raise_ms_exception();
36485 0 : msResetErrorList();
36486 0 : return NULL;
36487 : }
36488 : default:
36489 0 : _raise_ms_exception();
36490 0 : msResetErrorList();
36491 0 : return NULL;
36492 : }
36493 :
36494 : }
36495 : }
36496 : resultobj = SWIG_Py_Void();
36497 0 : return resultobj;
36498 0 : fail:
36499 : return NULL;
36500 : }
36501 :
36502 :
36503 0 : SWIGINTERN PyObject *_wrap_mapObj_applySLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36504 : PyObject *resultobj = 0;
36505 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36506 : char *arg2 = (char *) 0 ;
36507 0 : void *argp1 = 0 ;
36508 : int res1 = 0 ;
36509 : int res2 ;
36510 0 : char *buf2 = 0 ;
36511 0 : int alloc2 = 0 ;
36512 0 : PyObject * obj0 = 0 ;
36513 0 : PyObject * obj1 = 0 ;
36514 : int result;
36515 :
36516 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySLD",&obj0,&obj1)) SWIG_fail;
36517 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36518 0 : if (!SWIG_IsOK(res1)) {
36519 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySLD" "', argument " "1"" of type '" "struct mapObj *""'");
36520 : }
36521 0 : arg1 = (struct mapObj *)(argp1);
36522 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36523 0 : if (!SWIG_IsOK(res2)) {
36524 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_applySLD" "', argument " "2"" of type '" "char *""'");
36525 : }
36526 0 : arg2 = (char *)(buf2);
36527 : {
36528 : result = (int)mapObj_applySLD(arg1,arg2); {
36529 0 : errorObj *ms_error = msGetErrorObj();
36530 :
36531 0 : switch(ms_error->code) {
36532 : case MS_NOERR:
36533 : break;
36534 0 : case MS_NOTFOUND:
36535 0 : msResetErrorList();
36536 0 : break;
36537 : case -1:
36538 : break;
36539 0 : case MS_IOERR:
36540 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36541 0 : _raise_ms_exception();
36542 0 : msResetErrorList();
36543 0 : return NULL;
36544 : }
36545 : default:
36546 0 : _raise_ms_exception();
36547 0 : msResetErrorList();
36548 0 : return NULL;
36549 : }
36550 :
36551 : }
36552 : }
36553 : resultobj = SWIG_From_int((int)(result));
36554 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36555 : return resultobj;
36556 0 : fail:
36557 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36558 : return NULL;
36559 : }
36560 :
36561 :
36562 0 : SWIGINTERN PyObject *_wrap_mapObj_applySLDURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36563 : PyObject *resultobj = 0;
36564 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36565 : char *arg2 = (char *) 0 ;
36566 0 : void *argp1 = 0 ;
36567 : int res1 = 0 ;
36568 : int res2 ;
36569 0 : char *buf2 = 0 ;
36570 0 : int alloc2 = 0 ;
36571 0 : PyObject * obj0 = 0 ;
36572 0 : PyObject * obj1 = 0 ;
36573 : int result;
36574 :
36575 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySLDURL",&obj0,&obj1)) SWIG_fail;
36576 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36577 0 : if (!SWIG_IsOK(res1)) {
36578 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySLDURL" "', argument " "1"" of type '" "struct mapObj *""'");
36579 : }
36580 0 : arg1 = (struct mapObj *)(argp1);
36581 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36582 0 : if (!SWIG_IsOK(res2)) {
36583 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_applySLDURL" "', argument " "2"" of type '" "char *""'");
36584 : }
36585 0 : arg2 = (char *)(buf2);
36586 : {
36587 : result = (int)mapObj_applySLDURL(arg1,arg2); {
36588 0 : errorObj *ms_error = msGetErrorObj();
36589 :
36590 0 : switch(ms_error->code) {
36591 : case MS_NOERR:
36592 : break;
36593 0 : case MS_NOTFOUND:
36594 0 : msResetErrorList();
36595 0 : break;
36596 : case -1:
36597 : break;
36598 0 : case MS_IOERR:
36599 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36600 0 : _raise_ms_exception();
36601 0 : msResetErrorList();
36602 0 : return NULL;
36603 : }
36604 : default:
36605 0 : _raise_ms_exception();
36606 0 : msResetErrorList();
36607 0 : return NULL;
36608 : }
36609 :
36610 : }
36611 : }
36612 : resultobj = SWIG_From_int((int)(result));
36613 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36614 : return resultobj;
36615 0 : fail:
36616 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36617 : return NULL;
36618 : }
36619 :
36620 :
36621 1 : SWIGINTERN PyObject *_wrap_mapObj_generateSLD(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36622 : PyObject *resultobj = 0;
36623 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36624 : char *arg2 = (char *) NULL ;
36625 1 : void *argp1 = 0 ;
36626 : int res1 = 0 ;
36627 : int res2 ;
36628 1 : char *buf2 = 0 ;
36629 1 : int alloc2 = 0 ;
36630 1 : PyObject * obj0 = 0 ;
36631 1 : PyObject * obj1 = 0 ;
36632 : char *result = 0 ;
36633 :
36634 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:mapObj_generateSLD",&obj0,&obj1)) SWIG_fail;
36635 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36636 1 : if (!SWIG_IsOK(res1)) {
36637 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_generateSLD" "', argument " "1"" of type '" "struct mapObj *""'");
36638 : }
36639 1 : arg1 = (struct mapObj *)(argp1);
36640 1 : if (obj1) {
36641 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36642 1 : if (!SWIG_IsOK(res2)) {
36643 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_generateSLD" "', argument " "2"" of type '" "char *""'");
36644 : }
36645 1 : arg2 = (char *)(buf2);
36646 : }
36647 : {
36648 : result = (char *)mapObj_generateSLD(arg1,arg2); {
36649 1 : errorObj *ms_error = msGetErrorObj();
36650 :
36651 1 : switch(ms_error->code) {
36652 : case MS_NOERR:
36653 : break;
36654 0 : case MS_NOTFOUND:
36655 0 : msResetErrorList();
36656 0 : break;
36657 : case -1:
36658 : break;
36659 0 : case MS_IOERR:
36660 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36661 0 : _raise_ms_exception();
36662 0 : msResetErrorList();
36663 0 : return NULL;
36664 : }
36665 : default:
36666 0 : _raise_ms_exception();
36667 0 : msResetErrorList();
36668 0 : return NULL;
36669 : }
36670 :
36671 : }
36672 : }
36673 1 : resultobj = SWIG_FromCharPtr((const char *)result);
36674 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36675 1 : free((char*)result);
36676 1 : return resultobj;
36677 0 : fail:
36678 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36679 : return NULL;
36680 : }
36681 :
36682 :
36683 0 : SWIGINTERN PyObject *_wrap_mapObj_processTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36684 : PyObject *resultobj = 0;
36685 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36686 : int arg2 ;
36687 : char **arg3 = (char **) 0 ;
36688 : char **arg4 = (char **) 0 ;
36689 : int arg5 ;
36690 0 : void *argp1 = 0 ;
36691 : int res1 = 0 ;
36692 : int val2 ;
36693 : int ecode2 = 0 ;
36694 0 : void *argp3 = 0 ;
36695 : int res3 = 0 ;
36696 0 : void *argp4 = 0 ;
36697 : int res4 = 0 ;
36698 : int val5 ;
36699 : int ecode5 = 0 ;
36700 0 : PyObject * obj0 = 0 ;
36701 0 : PyObject * obj1 = 0 ;
36702 0 : PyObject * obj2 = 0 ;
36703 0 : PyObject * obj3 = 0 ;
36704 0 : PyObject * obj4 = 0 ;
36705 : char *result = 0 ;
36706 :
36707 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:mapObj_processTemplate",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
36708 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36709 0 : if (!SWIG_IsOK(res1)) {
36710 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processTemplate" "', argument " "1"" of type '" "struct mapObj *""'");
36711 : }
36712 0 : arg1 = (struct mapObj *)(argp1);
36713 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
36714 0 : if (!SWIG_IsOK(ecode2)) {
36715 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_processTemplate" "', argument " "2"" of type '" "int""'");
36716 : }
36717 : arg2 = (int)(val2);
36718 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 | 0 );
36719 0 : if (!SWIG_IsOK(res3)) {
36720 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processTemplate" "', argument " "3"" of type '" "char **""'");
36721 : }
36722 0 : arg3 = (char **)(argp3);
36723 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_p_char, 0 | 0 );
36724 0 : if (!SWIG_IsOK(res4)) {
36725 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "mapObj_processTemplate" "', argument " "4"" of type '" "char **""'");
36726 : }
36727 0 : arg4 = (char **)(argp4);
36728 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
36729 0 : if (!SWIG_IsOK(ecode5)) {
36730 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_processTemplate" "', argument " "5"" of type '" "int""'");
36731 : }
36732 : arg5 = (int)(val5);
36733 : {
36734 : result = (char *)mapObj_processTemplate(arg1,arg2,arg3,arg4,arg5); {
36735 0 : errorObj *ms_error = msGetErrorObj();
36736 :
36737 0 : switch(ms_error->code) {
36738 : case MS_NOERR:
36739 : break;
36740 0 : case MS_NOTFOUND:
36741 0 : msResetErrorList();
36742 0 : break;
36743 : case -1:
36744 : break;
36745 0 : case MS_IOERR:
36746 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36747 0 : _raise_ms_exception();
36748 0 : msResetErrorList();
36749 0 : return NULL;
36750 : }
36751 : default:
36752 0 : _raise_ms_exception();
36753 0 : msResetErrorList();
36754 0 : return NULL;
36755 : }
36756 :
36757 : }
36758 : }
36759 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36760 0 : free((char*)result);
36761 0 : return resultobj;
36762 0 : fail:
36763 : return NULL;
36764 : }
36765 :
36766 :
36767 0 : SWIGINTERN PyObject *_wrap_mapObj_processLegendTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36768 : PyObject *resultobj = 0;
36769 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36770 : char **arg2 = (char **) 0 ;
36771 : char **arg3 = (char **) 0 ;
36772 : int arg4 ;
36773 0 : void *argp1 = 0 ;
36774 : int res1 = 0 ;
36775 0 : void *argp2 = 0 ;
36776 : int res2 = 0 ;
36777 0 : void *argp3 = 0 ;
36778 : int res3 = 0 ;
36779 : int val4 ;
36780 : int ecode4 = 0 ;
36781 0 : PyObject * obj0 = 0 ;
36782 0 : PyObject * obj1 = 0 ;
36783 0 : PyObject * obj2 = 0 ;
36784 0 : PyObject * obj3 = 0 ;
36785 : char *result = 0 ;
36786 :
36787 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_processLegendTemplate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36788 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36789 0 : if (!SWIG_IsOK(res1)) {
36790 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processLegendTemplate" "', argument " "1"" of type '" "struct mapObj *""'");
36791 : }
36792 0 : arg1 = (struct mapObj *)(argp1);
36793 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 | 0 );
36794 0 : if (!SWIG_IsOK(res2)) {
36795 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_processLegendTemplate" "', argument " "2"" of type '" "char **""'");
36796 : }
36797 0 : arg2 = (char **)(argp2);
36798 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 | 0 );
36799 0 : if (!SWIG_IsOK(res3)) {
36800 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processLegendTemplate" "', argument " "3"" of type '" "char **""'");
36801 : }
36802 0 : arg3 = (char **)(argp3);
36803 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
36804 0 : if (!SWIG_IsOK(ecode4)) {
36805 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_processLegendTemplate" "', argument " "4"" of type '" "int""'");
36806 : }
36807 : arg4 = (int)(val4);
36808 : {
36809 : result = (char *)mapObj_processLegendTemplate(arg1,arg2,arg3,arg4); {
36810 0 : errorObj *ms_error = msGetErrorObj();
36811 :
36812 0 : switch(ms_error->code) {
36813 : case MS_NOERR:
36814 : break;
36815 0 : case MS_NOTFOUND:
36816 0 : msResetErrorList();
36817 0 : break;
36818 : case -1:
36819 : break;
36820 0 : case MS_IOERR:
36821 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36822 0 : _raise_ms_exception();
36823 0 : msResetErrorList();
36824 0 : return NULL;
36825 : }
36826 : default:
36827 0 : _raise_ms_exception();
36828 0 : msResetErrorList();
36829 0 : return NULL;
36830 : }
36831 :
36832 : }
36833 : }
36834 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36835 0 : free((char*)result);
36836 0 : return resultobj;
36837 0 : fail:
36838 : return NULL;
36839 : }
36840 :
36841 :
36842 0 : SWIGINTERN PyObject *_wrap_mapObj_processQueryTemplate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36843 : PyObject *resultobj = 0;
36844 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36845 : char **arg2 = (char **) 0 ;
36846 : char **arg3 = (char **) 0 ;
36847 : int arg4 ;
36848 0 : void *argp1 = 0 ;
36849 : int res1 = 0 ;
36850 0 : void *argp2 = 0 ;
36851 : int res2 = 0 ;
36852 0 : void *argp3 = 0 ;
36853 : int res3 = 0 ;
36854 : int val4 ;
36855 : int ecode4 = 0 ;
36856 0 : PyObject * obj0 = 0 ;
36857 0 : PyObject * obj1 = 0 ;
36858 0 : PyObject * obj2 = 0 ;
36859 0 : PyObject * obj3 = 0 ;
36860 : char *result = 0 ;
36861 :
36862 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:mapObj_processQueryTemplate",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36863 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36864 0 : if (!SWIG_IsOK(res1)) {
36865 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_processQueryTemplate" "', argument " "1"" of type '" "struct mapObj *""'");
36866 : }
36867 0 : arg1 = (struct mapObj *)(argp1);
36868 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_char, 0 | 0 );
36869 0 : if (!SWIG_IsOK(res2)) {
36870 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_processQueryTemplate" "', argument " "2"" of type '" "char **""'");
36871 : }
36872 0 : arg2 = (char **)(argp2);
36873 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_char, 0 | 0 );
36874 0 : if (!SWIG_IsOK(res3)) {
36875 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_processQueryTemplate" "', argument " "3"" of type '" "char **""'");
36876 : }
36877 0 : arg3 = (char **)(argp3);
36878 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
36879 0 : if (!SWIG_IsOK(ecode4)) {
36880 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_processQueryTemplate" "', argument " "4"" of type '" "int""'");
36881 : }
36882 : arg4 = (int)(val4);
36883 : {
36884 : result = (char *)mapObj_processQueryTemplate(arg1,arg2,arg3,arg4); {
36885 0 : errorObj *ms_error = msGetErrorObj();
36886 :
36887 0 : switch(ms_error->code) {
36888 : case MS_NOERR:
36889 : break;
36890 0 : case MS_NOTFOUND:
36891 0 : msResetErrorList();
36892 0 : break;
36893 : case -1:
36894 : break;
36895 0 : case MS_IOERR:
36896 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36897 0 : _raise_ms_exception();
36898 0 : msResetErrorList();
36899 0 : return NULL;
36900 : }
36901 : default:
36902 0 : _raise_ms_exception();
36903 0 : msResetErrorList();
36904 0 : return NULL;
36905 : }
36906 :
36907 : }
36908 : }
36909 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36910 0 : free((char*)result);
36911 0 : return resultobj;
36912 0 : fail:
36913 : return NULL;
36914 : }
36915 :
36916 :
36917 0 : SWIGINTERN PyObject *_wrap_mapObj_getOutputFormatByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36918 : PyObject *resultobj = 0;
36919 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36920 : char *arg2 = (char *) 0 ;
36921 0 : void *argp1 = 0 ;
36922 : int res1 = 0 ;
36923 : int res2 ;
36924 0 : char *buf2 = 0 ;
36925 0 : int alloc2 = 0 ;
36926 0 : PyObject * obj0 = 0 ;
36927 0 : PyObject * obj1 = 0 ;
36928 : outputFormatObj *result = 0 ;
36929 :
36930 0 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_getOutputFormatByName",&obj0,&obj1)) SWIG_fail;
36931 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36932 0 : if (!SWIG_IsOK(res1)) {
36933 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getOutputFormatByName" "', argument " "1"" of type '" "struct mapObj *""'");
36934 : }
36935 0 : arg1 = (struct mapObj *)(argp1);
36936 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36937 0 : if (!SWIG_IsOK(res2)) {
36938 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_getOutputFormatByName" "', argument " "2"" of type '" "char *""'");
36939 : }
36940 0 : arg2 = (char *)(buf2);
36941 : {
36942 : result = (outputFormatObj *)mapObj_getOutputFormatByName(arg1,arg2); {
36943 0 : errorObj *ms_error = msGetErrorObj();
36944 :
36945 0 : switch(ms_error->code) {
36946 : case MS_NOERR:
36947 : break;
36948 0 : case MS_NOTFOUND:
36949 0 : msResetErrorList();
36950 0 : break;
36951 : case -1:
36952 : break;
36953 0 : case MS_IOERR:
36954 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
36955 0 : _raise_ms_exception();
36956 0 : msResetErrorList();
36957 0 : return NULL;
36958 : }
36959 : default:
36960 0 : _raise_ms_exception();
36961 0 : msResetErrorList();
36962 0 : return NULL;
36963 : }
36964 :
36965 : }
36966 : }
36967 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_outputFormatObj, 0 | 0 );
36968 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36969 : return resultobj;
36970 0 : fail:
36971 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36972 : return NULL;
36973 : }
36974 :
36975 :
36976 1 : SWIGINTERN PyObject *_wrap_mapObj_appendOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36977 : PyObject *resultobj = 0;
36978 : struct mapObj *arg1 = (struct mapObj *) 0 ;
36979 : outputFormatObj *arg2 = (outputFormatObj *) 0 ;
36980 1 : void *argp1 = 0 ;
36981 : int res1 = 0 ;
36982 1 : void *argp2 = 0 ;
36983 : int res2 = 0 ;
36984 1 : PyObject * obj0 = 0 ;
36985 1 : PyObject * obj1 = 0 ;
36986 : int result;
36987 :
36988 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_appendOutputFormat",&obj0,&obj1)) SWIG_fail;
36989 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
36990 1 : if (!SWIG_IsOK(res1)) {
36991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_appendOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'");
36992 : }
36993 1 : arg1 = (struct mapObj *)(argp1);
36994 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 | 0 );
36995 1 : if (!SWIG_IsOK(res2)) {
36996 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_appendOutputFormat" "', argument " "2"" of type '" "outputFormatObj *""'");
36997 : }
36998 1 : arg2 = (outputFormatObj *)(argp2);
36999 : {
37000 : result = (int)mapObj_appendOutputFormat(arg1,arg2); {
37001 1 : errorObj *ms_error = msGetErrorObj();
37002 :
37003 1 : switch(ms_error->code) {
37004 : case MS_NOERR:
37005 : break;
37006 0 : case MS_NOTFOUND:
37007 0 : msResetErrorList();
37008 0 : break;
37009 : case -1:
37010 : break;
37011 0 : case MS_IOERR:
37012 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37013 0 : _raise_ms_exception();
37014 0 : msResetErrorList();
37015 0 : return NULL;
37016 : }
37017 : default:
37018 0 : _raise_ms_exception();
37019 0 : msResetErrorList();
37020 0 : return NULL;
37021 : }
37022 :
37023 : }
37024 : }
37025 : resultobj = SWIG_From_int((int)(result));
37026 1 : return resultobj;
37027 0 : fail:
37028 : return NULL;
37029 : }
37030 :
37031 :
37032 1 : SWIGINTERN PyObject *_wrap_mapObj_removeOutputFormat(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37033 : PyObject *resultobj = 0;
37034 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37035 : char *arg2 = (char *) 0 ;
37036 1 : void *argp1 = 0 ;
37037 : int res1 = 0 ;
37038 : int res2 ;
37039 1 : char *buf2 = 0 ;
37040 1 : int alloc2 = 0 ;
37041 1 : PyObject * obj0 = 0 ;
37042 1 : PyObject * obj1 = 0 ;
37043 : int result;
37044 :
37045 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_removeOutputFormat",&obj0,&obj1)) SWIG_fail;
37046 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37047 1 : if (!SWIG_IsOK(res1)) {
37048 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_removeOutputFormat" "', argument " "1"" of type '" "struct mapObj *""'");
37049 : }
37050 1 : arg1 = (struct mapObj *)(argp1);
37051 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
37052 1 : if (!SWIG_IsOK(res2)) {
37053 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_removeOutputFormat" "', argument " "2"" of type '" "char *""'");
37054 : }
37055 1 : arg2 = (char *)(buf2);
37056 : {
37057 : result = (int)mapObj_removeOutputFormat(arg1,arg2); {
37058 1 : errorObj *ms_error = msGetErrorObj();
37059 :
37060 1 : switch(ms_error->code) {
37061 : case MS_NOERR:
37062 : break;
37063 0 : case MS_NOTFOUND:
37064 0 : msResetErrorList();
37065 0 : break;
37066 : case -1:
37067 : break;
37068 0 : case MS_IOERR:
37069 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37070 0 : _raise_ms_exception();
37071 0 : msResetErrorList();
37072 0 : return NULL;
37073 : }
37074 : default:
37075 0 : _raise_ms_exception();
37076 0 : msResetErrorList();
37077 0 : return NULL;
37078 : }
37079 :
37080 : }
37081 : }
37082 : resultobj = SWIG_From_int((int)(result));
37083 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37084 : return resultobj;
37085 0 : fail:
37086 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
37087 : return NULL;
37088 : }
37089 :
37090 :
37091 1 : SWIGINTERN PyObject *_wrap_mapObj_loadOWSParameters(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37092 : PyObject *resultobj = 0;
37093 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37094 : cgiRequestObj *arg2 = (cgiRequestObj *) 0 ;
37095 : char *arg3 = (char *) "1.1.1" ;
37096 1 : void *argp1 = 0 ;
37097 : int res1 = 0 ;
37098 1 : void *argp2 = 0 ;
37099 : int res2 = 0 ;
37100 : int res3 ;
37101 1 : char *buf3 = 0 ;
37102 1 : int alloc3 = 0 ;
37103 1 : PyObject * obj0 = 0 ;
37104 1 : PyObject * obj1 = 0 ;
37105 1 : PyObject * obj2 = 0 ;
37106 : int result;
37107 :
37108 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:mapObj_loadOWSParameters",&obj0,&obj1,&obj2)) SWIG_fail;
37109 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37110 1 : if (!SWIG_IsOK(res1)) {
37111 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_loadOWSParameters" "', argument " "1"" of type '" "struct mapObj *""'");
37112 : }
37113 1 : arg1 = (struct mapObj *)(argp1);
37114 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
37115 1 : if (!SWIG_IsOK(res2)) {
37116 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_loadOWSParameters" "', argument " "2"" of type '" "cgiRequestObj *""'");
37117 : }
37118 1 : arg2 = (cgiRequestObj *)(argp2);
37119 1 : if (obj2) {
37120 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
37121 0 : if (!SWIG_IsOK(res3)) {
37122 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_loadOWSParameters" "', argument " "3"" of type '" "char *""'");
37123 : }
37124 0 : arg3 = (char *)(buf3);
37125 : }
37126 : {
37127 : result = (int)mapObj_loadOWSParameters(arg1,arg2,arg3); {
37128 1 : errorObj *ms_error = msGetErrorObj();
37129 :
37130 1 : switch(ms_error->code) {
37131 : case MS_NOERR:
37132 : break;
37133 0 : case MS_NOTFOUND:
37134 0 : msResetErrorList();
37135 0 : break;
37136 : case -1:
37137 : break;
37138 0 : case MS_IOERR:
37139 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37140 0 : _raise_ms_exception();
37141 0 : msResetErrorList();
37142 0 : return NULL;
37143 : }
37144 : default:
37145 0 : _raise_ms_exception();
37146 0 : msResetErrorList();
37147 0 : return NULL;
37148 : }
37149 :
37150 : }
37151 : }
37152 : resultobj = SWIG_From_int((int)(result));
37153 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
37154 : return resultobj;
37155 0 : fail:
37156 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
37157 : return NULL;
37158 : }
37159 :
37160 :
37161 1 : SWIGINTERN PyObject *_wrap_mapObj_OWSDispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37162 : PyObject *resultobj = 0;
37163 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37164 : cgiRequestObj *arg2 = (cgiRequestObj *) 0 ;
37165 1 : void *argp1 = 0 ;
37166 : int res1 = 0 ;
37167 1 : void *argp2 = 0 ;
37168 : int res2 = 0 ;
37169 1 : PyObject * obj0 = 0 ;
37170 1 : PyObject * obj1 = 0 ;
37171 : int result;
37172 :
37173 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_OWSDispatch",&obj0,&obj1)) SWIG_fail;
37174 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37175 1 : if (!SWIG_IsOK(res1)) {
37176 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_OWSDispatch" "', argument " "1"" of type '" "struct mapObj *""'");
37177 : }
37178 1 : arg1 = (struct mapObj *)(argp1);
37179 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
37180 1 : if (!SWIG_IsOK(res2)) {
37181 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_OWSDispatch" "', argument " "2"" of type '" "cgiRequestObj *""'");
37182 : }
37183 1 : arg2 = (cgiRequestObj *)(argp2);
37184 : {
37185 : result = (int)mapObj_OWSDispatch(arg1,arg2); {
37186 1 : errorObj *ms_error = msGetErrorObj();
37187 :
37188 1 : switch(ms_error->code) {
37189 : case MS_NOERR:
37190 : break;
37191 0 : case MS_NOTFOUND:
37192 0 : msResetErrorList();
37193 0 : break;
37194 : case -1:
37195 : break;
37196 0 : case MS_IOERR:
37197 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37198 0 : _raise_ms_exception();
37199 0 : msResetErrorList();
37200 0 : return NULL;
37201 : }
37202 : default:
37203 0 : _raise_ms_exception();
37204 0 : msResetErrorList();
37205 0 : return NULL;
37206 : }
37207 :
37208 : }
37209 : }
37210 : resultobj = SWIG_From_int((int)(result));
37211 1 : return resultobj;
37212 0 : fail:
37213 : return NULL;
37214 : }
37215 :
37216 :
37217 0 : SWIGINTERN PyObject *_wrap_mapObj_convertToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37218 : PyObject *resultobj = 0;
37219 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37220 0 : void *argp1 = 0 ;
37221 : int res1 = 0 ;
37222 0 : PyObject * obj0 = 0 ;
37223 : char *result = 0 ;
37224 :
37225 0 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_convertToString",&obj0)) SWIG_fail;
37226 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37227 0 : if (!SWIG_IsOK(res1)) {
37228 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_convertToString" "', argument " "1"" of type '" "struct mapObj *""'");
37229 : }
37230 0 : arg1 = (struct mapObj *)(argp1);
37231 : {
37232 : result = (char *)mapObj_convertToString(arg1); {
37233 0 : errorObj *ms_error = msGetErrorObj();
37234 :
37235 0 : switch(ms_error->code) {
37236 : case MS_NOERR:
37237 : break;
37238 0 : case MS_NOTFOUND:
37239 0 : msResetErrorList();
37240 0 : break;
37241 : case -1:
37242 : break;
37243 0 : case MS_IOERR:
37244 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37245 0 : _raise_ms_exception();
37246 0 : msResetErrorList();
37247 0 : return NULL;
37248 : }
37249 : default:
37250 0 : _raise_ms_exception();
37251 0 : msResetErrorList();
37252 0 : return NULL;
37253 : }
37254 :
37255 : }
37256 : }
37257 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37258 0 : free((char*)result);
37259 0 : return resultobj;
37260 0 : fail:
37261 : return NULL;
37262 : }
37263 :
37264 :
37265 1 : SWIGINTERN PyObject *_wrap_mapObj_applyDefaultSubstitutions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37266 : PyObject *resultobj = 0;
37267 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37268 1 : void *argp1 = 0 ;
37269 : int res1 = 0 ;
37270 1 : PyObject * obj0 = 0 ;
37271 :
37272 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_applyDefaultSubstitutions",&obj0)) SWIG_fail;
37273 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37274 1 : if (!SWIG_IsOK(res1)) {
37275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applyDefaultSubstitutions" "', argument " "1"" of type '" "struct mapObj *""'");
37276 : }
37277 1 : arg1 = (struct mapObj *)(argp1);
37278 : {
37279 : mapObj_applyDefaultSubstitutions(arg1); {
37280 1 : errorObj *ms_error = msGetErrorObj();
37281 :
37282 1 : switch(ms_error->code) {
37283 : case MS_NOERR:
37284 : break;
37285 0 : case MS_NOTFOUND:
37286 0 : msResetErrorList();
37287 0 : break;
37288 : case -1:
37289 : break;
37290 0 : case MS_IOERR:
37291 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37292 0 : _raise_ms_exception();
37293 0 : msResetErrorList();
37294 0 : return NULL;
37295 : }
37296 : default:
37297 0 : _raise_ms_exception();
37298 0 : msResetErrorList();
37299 0 : return NULL;
37300 : }
37301 :
37302 : }
37303 : }
37304 : resultobj = SWIG_Py_Void();
37305 1 : return resultobj;
37306 0 : fail:
37307 : return NULL;
37308 : }
37309 :
37310 :
37311 1 : SWIGINTERN PyObject *_wrap_mapObj_applySubstitutions(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37312 : PyObject *resultobj = 0;
37313 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37314 : char **arg2 = (char **) 0 ;
37315 : char **arg3 = (char **) 0 ;
37316 : int arg4 ;
37317 1 : void *argp1 = 0 ;
37318 : int res1 = 0 ;
37319 1 : PyObject * obj0 = 0 ;
37320 1 : PyObject * obj1 = 0 ;
37321 :
37322 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_applySubstitutions",&obj0,&obj1)) SWIG_fail;
37323 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37324 1 : if (!SWIG_IsOK(res1)) {
37325 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_applySubstitutions" "', argument " "1"" of type '" "struct mapObj *""'");
37326 : }
37327 1 : arg1 = (struct mapObj *)(argp1);
37328 : {
37329 : /* Check if is a dict */
37330 1 : if (PyDict_Check(obj1)) {
37331 : int i = 0;
37332 1 : int size = (int) PyDict_Size(obj1);
37333 :
37334 1 : PyObject* keys = PyDict_Keys(obj1);
37335 1 : PyObject* values = PyDict_Values(obj1);
37336 :
37337 : arg4 = size;
37338 1 : arg2 = (char **) malloc((size+1)*sizeof(char *));
37339 1 : arg3 = (char **) malloc((size+1)*sizeof(char *));
37340 :
37341 1 : for (i = 0; i < size; i++) {
37342 1 : PyObject* key = PyList_GetItem(keys, i);
37343 1 : PyObject* val = PyList_GetItem(values, i);
37344 :
37345 : #if PY_MAJOR_VERSION >= 3
37346 : // Changed in version 3.7: The return type is now const char * rather than char *
37347 : // avoid warning C4090: '=': different 'const' qualifiers
37348 1 : arg2[i] = (char *)PyUnicode_AsUTF8(key);
37349 1 : arg3[i] = (char *)PyUnicode_AsUTF8(val);
37350 : #else
37351 : arg2[i] = PyString_AsString(key);
37352 : arg3[i] = PyString_AsString(val);
37353 : #endif
37354 : }
37355 :
37356 1 : arg2[i] = 0;
37357 1 : arg3[i] = 0;
37358 :
37359 : } else {
37360 0 : PyErr_SetString(PyExc_TypeError, "Input not a dictionary");
37361 0 : SWIG_fail;
37362 : }
37363 : }
37364 : {
37365 : mapObj_applySubstitutions(arg1,arg2,arg3,arg4); {
37366 1 : errorObj *ms_error = msGetErrorObj();
37367 :
37368 1 : switch(ms_error->code) {
37369 : case MS_NOERR:
37370 : break;
37371 0 : case MS_NOTFOUND:
37372 0 : msResetErrorList();
37373 0 : break;
37374 : case -1:
37375 : break;
37376 0 : case MS_IOERR:
37377 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37378 0 : _raise_ms_exception();
37379 0 : msResetErrorList();
37380 0 : return NULL;
37381 : }
37382 : default:
37383 0 : _raise_ms_exception();
37384 0 : msResetErrorList();
37385 0 : return NULL;
37386 : }
37387 :
37388 : }
37389 : }
37390 : resultobj = SWIG_Py_Void();
37391 : {
37392 1 : free((char *) arg2);
37393 1 : free((char *) arg3);
37394 : }
37395 1 : return resultobj;
37396 0 : fail:
37397 : {
37398 : free((char *) arg2);
37399 : free((char *) arg3);
37400 : }
37401 0 : return NULL;
37402 : }
37403 :
37404 :
37405 1 : SWIGINTERN PyObject *_wrap_mapObj_zoomPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37406 : PyObject *resultobj = 0;
37407 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37408 : int arg2 ;
37409 : pointObj *arg3 = (pointObj *) 0 ;
37410 : int arg4 ;
37411 : int arg5 ;
37412 : rectObj *arg6 = (rectObj *) 0 ;
37413 : rectObj *arg7 = (rectObj *) 0 ;
37414 1 : void *argp1 = 0 ;
37415 : int res1 = 0 ;
37416 : int val2 ;
37417 : int ecode2 = 0 ;
37418 1 : void *argp3 = 0 ;
37419 : int res3 = 0 ;
37420 : int val4 ;
37421 : int ecode4 = 0 ;
37422 : int val5 ;
37423 : int ecode5 = 0 ;
37424 1 : void *argp6 = 0 ;
37425 : int res6 = 0 ;
37426 1 : void *argp7 = 0 ;
37427 : int res7 = 0 ;
37428 1 : PyObject * obj0 = 0 ;
37429 1 : PyObject * obj1 = 0 ;
37430 1 : PyObject * obj2 = 0 ;
37431 1 : PyObject * obj3 = 0 ;
37432 1 : PyObject * obj4 = 0 ;
37433 1 : PyObject * obj5 = 0 ;
37434 1 : PyObject * obj6 = 0 ;
37435 : int result;
37436 :
37437 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:mapObj_zoomPoint",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
37438 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37439 1 : if (!SWIG_IsOK(res1)) {
37440 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomPoint" "', argument " "1"" of type '" "struct mapObj *""'");
37441 : }
37442 1 : arg1 = (struct mapObj *)(argp1);
37443 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
37444 1 : if (!SWIG_IsOK(ecode2)) {
37445 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_zoomPoint" "', argument " "2"" of type '" "int""'");
37446 : }
37447 : arg2 = (int)(val2);
37448 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
37449 1 : if (!SWIG_IsOK(res3)) {
37450 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_zoomPoint" "', argument " "3"" of type '" "pointObj *""'");
37451 : }
37452 1 : arg3 = (pointObj *)(argp3);
37453 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
37454 1 : if (!SWIG_IsOK(ecode4)) {
37455 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomPoint" "', argument " "4"" of type '" "int""'");
37456 : }
37457 : arg4 = (int)(val4);
37458 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
37459 1 : if (!SWIG_IsOK(ecode5)) {
37460 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_zoomPoint" "', argument " "5"" of type '" "int""'");
37461 : }
37462 : arg5 = (int)(val5);
37463 1 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 | 0 );
37464 1 : if (!SWIG_IsOK(res6)) {
37465 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomPoint" "', argument " "6"" of type '" "rectObj *""'");
37466 : }
37467 1 : arg6 = (rectObj *)(argp6);
37468 1 : res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_rectObj, 0 | 0 );
37469 1 : if (!SWIG_IsOK(res7)) {
37470 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "mapObj_zoomPoint" "', argument " "7"" of type '" "rectObj *""'");
37471 : }
37472 1 : arg7 = (rectObj *)(argp7);
37473 : {
37474 1 : result = (int)mapObj_zoomPoint(arg1,arg2,arg3,arg4,arg5,arg6,arg7); {
37475 1 : errorObj *ms_error = msGetErrorObj();
37476 :
37477 1 : switch(ms_error->code) {
37478 : case MS_NOERR:
37479 : break;
37480 0 : case MS_NOTFOUND:
37481 0 : msResetErrorList();
37482 0 : break;
37483 : case -1:
37484 : break;
37485 0 : case MS_IOERR:
37486 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37487 0 : _raise_ms_exception();
37488 0 : msResetErrorList();
37489 0 : return NULL;
37490 : }
37491 : default:
37492 1 : _raise_ms_exception();
37493 1 : msResetErrorList();
37494 1 : return NULL;
37495 : }
37496 :
37497 : }
37498 : }
37499 : resultobj = SWIG_From_int((int)(result));
37500 1 : return resultobj;
37501 0 : fail:
37502 : return NULL;
37503 : }
37504 :
37505 :
37506 1 : SWIGINTERN PyObject *_wrap_mapObj_zoomRectangle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37507 : PyObject *resultobj = 0;
37508 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37509 : rectObj *arg2 = (rectObj *) 0 ;
37510 : int arg3 ;
37511 : int arg4 ;
37512 : rectObj *arg5 = (rectObj *) 0 ;
37513 : rectObj *arg6 = (rectObj *) 0 ;
37514 1 : void *argp1 = 0 ;
37515 : int res1 = 0 ;
37516 1 : void *argp2 = 0 ;
37517 : int res2 = 0 ;
37518 : int val3 ;
37519 : int ecode3 = 0 ;
37520 : int val4 ;
37521 : int ecode4 = 0 ;
37522 1 : void *argp5 = 0 ;
37523 : int res5 = 0 ;
37524 1 : void *argp6 = 0 ;
37525 : int res6 = 0 ;
37526 1 : PyObject * obj0 = 0 ;
37527 1 : PyObject * obj1 = 0 ;
37528 1 : PyObject * obj2 = 0 ;
37529 1 : PyObject * obj3 = 0 ;
37530 1 : PyObject * obj4 = 0 ;
37531 1 : PyObject * obj5 = 0 ;
37532 : int result;
37533 :
37534 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:mapObj_zoomRectangle",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
37535 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37536 1 : if (!SWIG_IsOK(res1)) {
37537 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomRectangle" "', argument " "1"" of type '" "struct mapObj *""'");
37538 : }
37539 1 : arg1 = (struct mapObj *)(argp1);
37540 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 | 0 );
37541 1 : if (!SWIG_IsOK(res2)) {
37542 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "mapObj_zoomRectangle" "', argument " "2"" of type '" "rectObj *""'");
37543 : }
37544 1 : arg2 = (rectObj *)(argp2);
37545 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
37546 1 : if (!SWIG_IsOK(ecode3)) {
37547 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "mapObj_zoomRectangle" "', argument " "3"" of type '" "int""'");
37548 : }
37549 : arg3 = (int)(val3);
37550 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
37551 1 : if (!SWIG_IsOK(ecode4)) {
37552 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomRectangle" "', argument " "4"" of type '" "int""'");
37553 : }
37554 : arg4 = (int)(val4);
37555 1 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_rectObj, 0 | 0 );
37556 1 : if (!SWIG_IsOK(res5)) {
37557 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "mapObj_zoomRectangle" "', argument " "5"" of type '" "rectObj *""'");
37558 : }
37559 1 : arg5 = (rectObj *)(argp5);
37560 1 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 | 0 );
37561 1 : if (!SWIG_IsOK(res6)) {
37562 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomRectangle" "', argument " "6"" of type '" "rectObj *""'");
37563 : }
37564 1 : arg6 = (rectObj *)(argp6);
37565 : {
37566 1 : result = (int)mapObj_zoomRectangle(arg1,arg2,arg3,arg4,arg5,arg6); {
37567 1 : errorObj *ms_error = msGetErrorObj();
37568 :
37569 1 : switch(ms_error->code) {
37570 : case MS_NOERR:
37571 : break;
37572 0 : case MS_NOTFOUND:
37573 0 : msResetErrorList();
37574 0 : break;
37575 : case -1:
37576 : break;
37577 0 : case MS_IOERR:
37578 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37579 0 : _raise_ms_exception();
37580 0 : msResetErrorList();
37581 0 : return NULL;
37582 : }
37583 : default:
37584 1 : _raise_ms_exception();
37585 1 : msResetErrorList();
37586 1 : return NULL;
37587 : }
37588 :
37589 : }
37590 : }
37591 : resultobj = SWIG_From_int((int)(result));
37592 1 : return resultobj;
37593 0 : fail:
37594 : return NULL;
37595 : }
37596 :
37597 :
37598 1 : SWIGINTERN PyObject *_wrap_mapObj_zoomScale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37599 : PyObject *resultobj = 0;
37600 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37601 : double arg2 ;
37602 : pointObj *arg3 = (pointObj *) 0 ;
37603 : int arg4 ;
37604 : int arg5 ;
37605 : rectObj *arg6 = (rectObj *) 0 ;
37606 : rectObj *arg7 = (rectObj *) 0 ;
37607 1 : void *argp1 = 0 ;
37608 : int res1 = 0 ;
37609 : double val2 ;
37610 : int ecode2 = 0 ;
37611 1 : void *argp3 = 0 ;
37612 : int res3 = 0 ;
37613 : int val4 ;
37614 : int ecode4 = 0 ;
37615 : int val5 ;
37616 : int ecode5 = 0 ;
37617 1 : void *argp6 = 0 ;
37618 : int res6 = 0 ;
37619 1 : void *argp7 = 0 ;
37620 : int res7 = 0 ;
37621 1 : PyObject * obj0 = 0 ;
37622 1 : PyObject * obj1 = 0 ;
37623 1 : PyObject * obj2 = 0 ;
37624 1 : PyObject * obj3 = 0 ;
37625 1 : PyObject * obj4 = 0 ;
37626 1 : PyObject * obj5 = 0 ;
37627 1 : PyObject * obj6 = 0 ;
37628 : int result;
37629 :
37630 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:mapObj_zoomScale",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
37631 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37632 1 : if (!SWIG_IsOK(res1)) {
37633 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_zoomScale" "', argument " "1"" of type '" "struct mapObj *""'");
37634 : }
37635 1 : arg1 = (struct mapObj *)(argp1);
37636 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
37637 1 : if (!SWIG_IsOK(ecode2)) {
37638 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "mapObj_zoomScale" "', argument " "2"" of type '" "double""'");
37639 : }
37640 1 : arg2 = (double)(val2);
37641 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
37642 1 : if (!SWIG_IsOK(res3)) {
37643 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "mapObj_zoomScale" "', argument " "3"" of type '" "pointObj *""'");
37644 : }
37645 1 : arg3 = (pointObj *)(argp3);
37646 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
37647 1 : if (!SWIG_IsOK(ecode4)) {
37648 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "mapObj_zoomScale" "', argument " "4"" of type '" "int""'");
37649 : }
37650 : arg4 = (int)(val4);
37651 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
37652 1 : if (!SWIG_IsOK(ecode5)) {
37653 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "mapObj_zoomScale" "', argument " "5"" of type '" "int""'");
37654 : }
37655 : arg5 = (int)(val5);
37656 1 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_rectObj, 0 | 0 );
37657 1 : if (!SWIG_IsOK(res6)) {
37658 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "mapObj_zoomScale" "', argument " "6"" of type '" "rectObj *""'");
37659 : }
37660 1 : arg6 = (rectObj *)(argp6);
37661 1 : res7 = SWIG_ConvertPtr(obj6, &argp7,SWIGTYPE_p_rectObj, 0 | 0 );
37662 1 : if (!SWIG_IsOK(res7)) {
37663 0 : SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "mapObj_zoomScale" "', argument " "7"" of type '" "rectObj *""'");
37664 : }
37665 1 : arg7 = (rectObj *)(argp7);
37666 : {
37667 1 : result = (int)mapObj_zoomScale(arg1,arg2,arg3,arg4,arg5,arg6,arg7); {
37668 1 : errorObj *ms_error = msGetErrorObj();
37669 :
37670 1 : switch(ms_error->code) {
37671 : case MS_NOERR:
37672 : break;
37673 0 : case MS_NOTFOUND:
37674 0 : msResetErrorList();
37675 0 : break;
37676 : case -1:
37677 : break;
37678 0 : case MS_IOERR:
37679 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37680 0 : _raise_ms_exception();
37681 0 : msResetErrorList();
37682 0 : return NULL;
37683 : }
37684 : default:
37685 0 : _raise_ms_exception();
37686 0 : msResetErrorList();
37687 0 : return NULL;
37688 : }
37689 :
37690 : }
37691 : }
37692 : resultobj = SWIG_From_int((int)(result));
37693 1 : return resultobj;
37694 0 : fail:
37695 : return NULL;
37696 : }
37697 :
37698 :
37699 1 : SWIGINTERN PyObject *_wrap_mapObj_getLayerOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37700 : PyObject *resultobj = 0;
37701 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37702 1 : void *argp1 = 0 ;
37703 : int res1 = 0 ;
37704 1 : PyObject * obj0 = 0 ;
37705 : PyObject *result = 0 ;
37706 :
37707 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getLayerOrder",&obj0)) SWIG_fail;
37708 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37709 1 : if (!SWIG_IsOK(res1)) {
37710 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getLayerOrder" "', argument " "1"" of type '" "struct mapObj *""'");
37711 : }
37712 1 : arg1 = (struct mapObj *)(argp1);
37713 : {
37714 1 : result = (PyObject *)mapObj_getLayerOrder(arg1); {
37715 1 : errorObj *ms_error = msGetErrorObj();
37716 :
37717 1 : switch(ms_error->code) {
37718 : case MS_NOERR:
37719 : break;
37720 0 : case MS_NOTFOUND:
37721 0 : msResetErrorList();
37722 0 : break;
37723 : case -1:
37724 : break;
37725 0 : case MS_IOERR:
37726 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37727 0 : _raise_ms_exception();
37728 0 : msResetErrorList();
37729 0 : return NULL;
37730 : }
37731 : default:
37732 0 : _raise_ms_exception();
37733 0 : msResetErrorList();
37734 0 : return NULL;
37735 : }
37736 :
37737 : }
37738 : }
37739 : resultobj = result;
37740 : return resultobj;
37741 0 : fail:
37742 : return NULL;
37743 : }
37744 :
37745 :
37746 1 : SWIGINTERN PyObject *_wrap_mapObj_setLayerOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37747 : PyObject *resultobj = 0;
37748 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37749 : PyObject *arg2 = (PyObject *) 0 ;
37750 1 : void *argp1 = 0 ;
37751 : int res1 = 0 ;
37752 1 : PyObject * obj0 = 0 ;
37753 1 : PyObject * obj1 = 0 ;
37754 : int result;
37755 :
37756 1 : if (!PyArg_ParseTuple(args,(char *)"OO:mapObj_setLayerOrder",&obj0,&obj1)) SWIG_fail;
37757 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37758 1 : if (!SWIG_IsOK(res1)) {
37759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_setLayerOrder" "', argument " "1"" of type '" "struct mapObj *""'");
37760 : }
37761 1 : arg1 = (struct mapObj *)(argp1);
37762 1 : arg2 = obj1;
37763 : {
37764 1 : result = (int)mapObj_setLayerOrder(arg1,arg2); {
37765 1 : errorObj *ms_error = msGetErrorObj();
37766 :
37767 1 : switch(ms_error->code) {
37768 : case MS_NOERR:
37769 : break;
37770 0 : case MS_NOTFOUND:
37771 0 : msResetErrorList();
37772 0 : break;
37773 : case -1:
37774 : break;
37775 0 : case MS_IOERR:
37776 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37777 0 : _raise_ms_exception();
37778 0 : msResetErrorList();
37779 0 : return NULL;
37780 : }
37781 : default:
37782 0 : _raise_ms_exception();
37783 0 : msResetErrorList();
37784 0 : return NULL;
37785 : }
37786 :
37787 : }
37788 : }
37789 : resultobj = SWIG_From_int((int)(result));
37790 1 : return resultobj;
37791 0 : fail:
37792 : return NULL;
37793 : }
37794 :
37795 :
37796 1 : SWIGINTERN PyObject *_wrap_mapObj_getSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37797 : PyObject *resultobj = 0;
37798 : struct mapObj *arg1 = (struct mapObj *) 0 ;
37799 1 : void *argp1 = 0 ;
37800 : int res1 = 0 ;
37801 1 : PyObject * obj0 = 0 ;
37802 : PyObject *result = 0 ;
37803 :
37804 1 : if (!PyArg_ParseTuple(args,(char *)"O:mapObj_getSize",&obj0)) SWIG_fail;
37805 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37806 1 : if (!SWIG_IsOK(res1)) {
37807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "mapObj_getSize" "', argument " "1"" of type '" "struct mapObj *""'");
37808 : }
37809 1 : arg1 = (struct mapObj *)(argp1);
37810 : {
37811 1 : result = (PyObject *)mapObj_getSize(arg1); {
37812 1 : errorObj *ms_error = msGetErrorObj();
37813 :
37814 1 : switch(ms_error->code) {
37815 : case MS_NOERR:
37816 : break;
37817 0 : case MS_NOTFOUND:
37818 0 : msResetErrorList();
37819 0 : break;
37820 : case -1:
37821 : break;
37822 0 : case MS_IOERR:
37823 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37824 0 : _raise_ms_exception();
37825 0 : msResetErrorList();
37826 0 : return NULL;
37827 : }
37828 : default:
37829 0 : _raise_ms_exception();
37830 0 : msResetErrorList();
37831 0 : return NULL;
37832 : }
37833 :
37834 : }
37835 : }
37836 : resultobj = result;
37837 : return resultobj;
37838 0 : fail:
37839 : return NULL;
37840 : }
37841 :
37842 :
37843 1 : SWIGINTERN PyObject *mapObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37844 : PyObject *obj;
37845 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
37846 1 : SWIG_TypeNewClientData(SWIGTYPE_p_mapObj, SWIG_NewClientData(obj));
37847 1 : return SWIG_Py_Void();
37848 : }
37849 :
37850 0 : SWIGINTERN PyObject *_wrap_msSaveImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37851 : PyObject *resultobj = 0;
37852 : mapObj *arg1 = (mapObj *) 0 ;
37853 : imageObj *arg2 = (imageObj *) 0 ;
37854 : char *arg3 = (char *) 0 ;
37855 0 : void *argp1 = 0 ;
37856 : int res1 = 0 ;
37857 0 : void *argp2 = 0 ;
37858 : int res2 = 0 ;
37859 : int res3 ;
37860 0 : char *buf3 = 0 ;
37861 0 : int alloc3 = 0 ;
37862 0 : PyObject * obj0 = 0 ;
37863 0 : PyObject * obj1 = 0 ;
37864 0 : PyObject * obj2 = 0 ;
37865 : int result;
37866 :
37867 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:msSaveImage",&obj0,&obj1,&obj2)) SWIG_fail;
37868 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_mapObj, 0 | 0 );
37869 0 : if (!SWIG_IsOK(res1)) {
37870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msSaveImage" "', argument " "1"" of type '" "mapObj *""'");
37871 : }
37872 0 : arg1 = (mapObj *)(argp1);
37873 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 | 0 );
37874 0 : if (!SWIG_IsOK(res2)) {
37875 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "msSaveImage" "', argument " "2"" of type '" "imageObj *""'");
37876 : }
37877 0 : arg2 = (imageObj *)(argp2);
37878 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
37879 0 : if (!SWIG_IsOK(res3)) {
37880 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "msSaveImage" "', argument " "3"" of type '" "char const *""'");
37881 : }
37882 0 : arg3 = (char *)(buf3);
37883 : {
37884 0 : result = (int)msSaveImage(arg1,arg2,(char const *)arg3); {
37885 0 : errorObj *ms_error = msGetErrorObj();
37886 :
37887 0 : switch(ms_error->code) {
37888 : case MS_NOERR:
37889 : break;
37890 0 : case MS_NOTFOUND:
37891 0 : msResetErrorList();
37892 0 : break;
37893 : case -1:
37894 : break;
37895 0 : case MS_IOERR:
37896 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37897 0 : _raise_ms_exception();
37898 0 : msResetErrorList();
37899 0 : return NULL;
37900 : }
37901 : default:
37902 0 : _raise_ms_exception();
37903 0 : msResetErrorList();
37904 0 : return NULL;
37905 : }
37906 :
37907 : }
37908 : }
37909 : resultobj = SWIG_From_int((int)(result));
37910 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
37911 : return resultobj;
37912 0 : fail:
37913 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
37914 : return NULL;
37915 : }
37916 :
37917 :
37918 0 : SWIGINTERN PyObject *_wrap_msFreeImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37919 : PyObject *resultobj = 0;
37920 : imageObj *arg1 = (imageObj *) 0 ;
37921 0 : void *argp1 = 0 ;
37922 : int res1 = 0 ;
37923 0 : PyObject * obj0 = 0 ;
37924 :
37925 0 : if (!PyArg_ParseTuple(args,(char *)"O:msFreeImage",&obj0)) SWIG_fail;
37926 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_imageObj, 0 | 0 );
37927 0 : if (!SWIG_IsOK(res1)) {
37928 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msFreeImage" "', argument " "1"" of type '" "imageObj *""'");
37929 : }
37930 0 : arg1 = (imageObj *)(argp1);
37931 : {
37932 0 : msFreeImage(arg1); {
37933 0 : errorObj *ms_error = msGetErrorObj();
37934 :
37935 0 : switch(ms_error->code) {
37936 : case MS_NOERR:
37937 : break;
37938 0 : case MS_NOTFOUND:
37939 0 : msResetErrorList();
37940 0 : break;
37941 : case -1:
37942 : break;
37943 0 : case MS_IOERR:
37944 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37945 0 : _raise_ms_exception();
37946 0 : msResetErrorList();
37947 0 : return NULL;
37948 : }
37949 : default:
37950 0 : _raise_ms_exception();
37951 0 : msResetErrorList();
37952 0 : return NULL;
37953 : }
37954 :
37955 : }
37956 : }
37957 : resultobj = SWIG_Py_Void();
37958 0 : return resultobj;
37959 0 : fail:
37960 : return NULL;
37961 : }
37962 :
37963 :
37964 0 : SWIGINTERN PyObject *_wrap_msSetup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37965 : PyObject *resultobj = 0;
37966 : int result;
37967 :
37968 0 : if (!PyArg_ParseTuple(args,(char *)":msSetup")) SWIG_fail;
37969 : {
37970 0 : result = (int)msSetup(); {
37971 0 : errorObj *ms_error = msGetErrorObj();
37972 :
37973 0 : switch(ms_error->code) {
37974 : case MS_NOERR:
37975 : break;
37976 0 : case MS_NOTFOUND:
37977 0 : msResetErrorList();
37978 0 : break;
37979 : case -1:
37980 : break;
37981 0 : case MS_IOERR:
37982 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
37983 0 : _raise_ms_exception();
37984 0 : msResetErrorList();
37985 0 : return NULL;
37986 : }
37987 : default:
37988 0 : _raise_ms_exception();
37989 0 : msResetErrorList();
37990 0 : return NULL;
37991 : }
37992 :
37993 : }
37994 : }
37995 : resultobj = SWIG_From_int((int)(result));
37996 0 : return resultobj;
37997 0 : fail:
37998 : return NULL;
37999 : }
38000 :
38001 :
38002 0 : SWIGINTERN PyObject *_wrap_msCleanup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38003 : PyObject *resultobj = 0;
38004 :
38005 0 : if (!PyArg_ParseTuple(args,(char *)":msCleanup")) SWIG_fail;
38006 : {
38007 0 : msCleanup(); {
38008 0 : errorObj *ms_error = msGetErrorObj();
38009 :
38010 0 : switch(ms_error->code) {
38011 : case MS_NOERR:
38012 : break;
38013 0 : case MS_NOTFOUND:
38014 0 : msResetErrorList();
38015 0 : break;
38016 : case -1:
38017 : break;
38018 0 : case MS_IOERR:
38019 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38020 0 : _raise_ms_exception();
38021 0 : msResetErrorList();
38022 0 : return NULL;
38023 : }
38024 : default:
38025 0 : _raise_ms_exception();
38026 0 : msResetErrorList();
38027 0 : return NULL;
38028 : }
38029 :
38030 : }
38031 : }
38032 : resultobj = SWIG_Py_Void();
38033 0 : return resultobj;
38034 0 : fail:
38035 : return NULL;
38036 : }
38037 :
38038 :
38039 1 : SWIGINTERN PyObject *_wrap_msLoadMapFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38040 : PyObject *resultobj = 0;
38041 : char *arg1 = (char *) 0 ;
38042 : char *arg2 = (char *) 0 ;
38043 : int res1 ;
38044 1 : char *buf1 = 0 ;
38045 1 : int alloc1 = 0 ;
38046 : int res2 ;
38047 1 : char *buf2 = 0 ;
38048 1 : int alloc2 = 0 ;
38049 1 : PyObject * obj0 = 0 ;
38050 1 : PyObject * obj1 = 0 ;
38051 : mapObj *result = 0 ;
38052 :
38053 1 : if (!PyArg_ParseTuple(args,(char *)"OO:msLoadMapFromString",&obj0,&obj1)) SWIG_fail;
38054 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
38055 1 : if (!SWIG_IsOK(res1)) {
38056 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msLoadMapFromString" "', argument " "1"" of type '" "char *""'");
38057 : }
38058 1 : arg1 = (char *)(buf1);
38059 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
38060 1 : if (!SWIG_IsOK(res2)) {
38061 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "msLoadMapFromString" "', argument " "2"" of type '" "char *""'");
38062 : }
38063 1 : arg2 = (char *)(buf2);
38064 : {
38065 1 : result = (mapObj *)msLoadMapFromString(arg1,arg2); {
38066 1 : errorObj *ms_error = msGetErrorObj();
38067 :
38068 1 : switch(ms_error->code) {
38069 : case MS_NOERR:
38070 : break;
38071 0 : case MS_NOTFOUND:
38072 0 : msResetErrorList();
38073 0 : break;
38074 : case -1:
38075 : break;
38076 0 : case MS_IOERR:
38077 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38078 0 : _raise_ms_exception();
38079 0 : msResetErrorList();
38080 0 : return NULL;
38081 : }
38082 : default:
38083 0 : _raise_ms_exception();
38084 0 : msResetErrorList();
38085 0 : return NULL;
38086 : }
38087 :
38088 : }
38089 : }
38090 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_mapObj, SWIG_POINTER_OWN | 0 );
38091 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
38092 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38093 : return resultobj;
38094 0 : fail:
38095 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
38096 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
38097 : return NULL;
38098 : }
38099 :
38100 :
38101 1 : SWIGINTERN PyObject *_wrap_rectObj_minx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38102 : PyObject *resultobj = 0;
38103 : rectObj *arg1 = (rectObj *) 0 ;
38104 : double arg2 ;
38105 1 : void *argp1 = 0 ;
38106 : int res1 = 0 ;
38107 : double val2 ;
38108 : int ecode2 = 0 ;
38109 1 : PyObject * obj0 = 0 ;
38110 1 : PyObject * obj1 = 0 ;
38111 :
38112 1 : if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_minx_set",&obj0,&obj1)) SWIG_fail;
38113 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38114 1 : if (!SWIG_IsOK(res1)) {
38115 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_minx_set" "', argument " "1"" of type '" "rectObj *""'");
38116 : }
38117 1 : arg1 = (rectObj *)(argp1);
38118 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38119 1 : if (!SWIG_IsOK(ecode2)) {
38120 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_minx_set" "', argument " "2"" of type '" "double""'");
38121 : }
38122 1 : arg2 = (double)(val2);
38123 1 : if (arg1) (arg1)->minx = arg2;
38124 : resultobj = SWIG_Py_Void();
38125 1 : return resultobj;
38126 0 : fail:
38127 : return NULL;
38128 : }
38129 :
38130 :
38131 1 : SWIGINTERN PyObject *_wrap_rectObj_minx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38132 : PyObject *resultobj = 0;
38133 : rectObj *arg1 = (rectObj *) 0 ;
38134 1 : void *argp1 = 0 ;
38135 : int res1 = 0 ;
38136 1 : PyObject * obj0 = 0 ;
38137 : double result;
38138 :
38139 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_minx_get",&obj0)) SWIG_fail;
38140 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38141 1 : if (!SWIG_IsOK(res1)) {
38142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_minx_get" "', argument " "1"" of type '" "rectObj *""'");
38143 : }
38144 1 : arg1 = (rectObj *)(argp1);
38145 1 : result = (double) ((arg1)->minx);
38146 1 : resultobj = SWIG_From_double((double)(result));
38147 1 : return resultobj;
38148 0 : fail:
38149 : return NULL;
38150 : }
38151 :
38152 :
38153 1 : SWIGINTERN PyObject *_wrap_rectObj_miny_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38154 : PyObject *resultobj = 0;
38155 : rectObj *arg1 = (rectObj *) 0 ;
38156 : double arg2 ;
38157 1 : void *argp1 = 0 ;
38158 : int res1 = 0 ;
38159 : double val2 ;
38160 : int ecode2 = 0 ;
38161 1 : PyObject * obj0 = 0 ;
38162 1 : PyObject * obj1 = 0 ;
38163 :
38164 1 : if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_miny_set",&obj0,&obj1)) SWIG_fail;
38165 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38166 1 : if (!SWIG_IsOK(res1)) {
38167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_miny_set" "', argument " "1"" of type '" "rectObj *""'");
38168 : }
38169 1 : arg1 = (rectObj *)(argp1);
38170 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38171 1 : if (!SWIG_IsOK(ecode2)) {
38172 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_miny_set" "', argument " "2"" of type '" "double""'");
38173 : }
38174 1 : arg2 = (double)(val2);
38175 1 : if (arg1) (arg1)->miny = arg2;
38176 : resultobj = SWIG_Py_Void();
38177 1 : return resultobj;
38178 0 : fail:
38179 : return NULL;
38180 : }
38181 :
38182 :
38183 1 : SWIGINTERN PyObject *_wrap_rectObj_miny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38184 : PyObject *resultobj = 0;
38185 : rectObj *arg1 = (rectObj *) 0 ;
38186 1 : void *argp1 = 0 ;
38187 : int res1 = 0 ;
38188 1 : PyObject * obj0 = 0 ;
38189 : double result;
38190 :
38191 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_miny_get",&obj0)) SWIG_fail;
38192 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38193 1 : if (!SWIG_IsOK(res1)) {
38194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_miny_get" "', argument " "1"" of type '" "rectObj *""'");
38195 : }
38196 1 : arg1 = (rectObj *)(argp1);
38197 1 : result = (double) ((arg1)->miny);
38198 1 : resultobj = SWIG_From_double((double)(result));
38199 1 : return resultobj;
38200 0 : fail:
38201 : return NULL;
38202 : }
38203 :
38204 :
38205 1 : SWIGINTERN PyObject *_wrap_rectObj_maxx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38206 : PyObject *resultobj = 0;
38207 : rectObj *arg1 = (rectObj *) 0 ;
38208 : double arg2 ;
38209 1 : void *argp1 = 0 ;
38210 : int res1 = 0 ;
38211 : double val2 ;
38212 : int ecode2 = 0 ;
38213 1 : PyObject * obj0 = 0 ;
38214 1 : PyObject * obj1 = 0 ;
38215 :
38216 1 : if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_maxx_set",&obj0,&obj1)) SWIG_fail;
38217 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38218 1 : if (!SWIG_IsOK(res1)) {
38219 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxx_set" "', argument " "1"" of type '" "rectObj *""'");
38220 : }
38221 1 : arg1 = (rectObj *)(argp1);
38222 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38223 1 : if (!SWIG_IsOK(ecode2)) {
38224 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_maxx_set" "', argument " "2"" of type '" "double""'");
38225 : }
38226 1 : arg2 = (double)(val2);
38227 1 : if (arg1) (arg1)->maxx = arg2;
38228 : resultobj = SWIG_Py_Void();
38229 1 : return resultobj;
38230 0 : fail:
38231 : return NULL;
38232 : }
38233 :
38234 :
38235 1 : SWIGINTERN PyObject *_wrap_rectObj_maxx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38236 : PyObject *resultobj = 0;
38237 : rectObj *arg1 = (rectObj *) 0 ;
38238 1 : void *argp1 = 0 ;
38239 : int res1 = 0 ;
38240 1 : PyObject * obj0 = 0 ;
38241 : double result;
38242 :
38243 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_maxx_get",&obj0)) SWIG_fail;
38244 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38245 1 : if (!SWIG_IsOK(res1)) {
38246 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxx_get" "', argument " "1"" of type '" "rectObj *""'");
38247 : }
38248 1 : arg1 = (rectObj *)(argp1);
38249 1 : result = (double) ((arg1)->maxx);
38250 1 : resultobj = SWIG_From_double((double)(result));
38251 1 : return resultobj;
38252 0 : fail:
38253 : return NULL;
38254 : }
38255 :
38256 :
38257 1 : SWIGINTERN PyObject *_wrap_rectObj_maxy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38258 : PyObject *resultobj = 0;
38259 : rectObj *arg1 = (rectObj *) 0 ;
38260 : double arg2 ;
38261 1 : void *argp1 = 0 ;
38262 : int res1 = 0 ;
38263 : double val2 ;
38264 : int ecode2 = 0 ;
38265 1 : PyObject * obj0 = 0 ;
38266 1 : PyObject * obj1 = 0 ;
38267 :
38268 1 : if (!PyArg_ParseTuple(args,(char *)"OO:rectObj_maxy_set",&obj0,&obj1)) SWIG_fail;
38269 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38270 1 : if (!SWIG_IsOK(res1)) {
38271 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxy_set" "', argument " "1"" of type '" "rectObj *""'");
38272 : }
38273 1 : arg1 = (rectObj *)(argp1);
38274 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38275 1 : if (!SWIG_IsOK(ecode2)) {
38276 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_maxy_set" "', argument " "2"" of type '" "double""'");
38277 : }
38278 1 : arg2 = (double)(val2);
38279 1 : if (arg1) (arg1)->maxy = arg2;
38280 : resultobj = SWIG_Py_Void();
38281 1 : return resultobj;
38282 0 : fail:
38283 : return NULL;
38284 : }
38285 :
38286 :
38287 1 : SWIGINTERN PyObject *_wrap_rectObj_maxy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38288 : PyObject *resultobj = 0;
38289 : rectObj *arg1 = (rectObj *) 0 ;
38290 1 : void *argp1 = 0 ;
38291 : int res1 = 0 ;
38292 1 : PyObject * obj0 = 0 ;
38293 : double result;
38294 :
38295 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_maxy_get",&obj0)) SWIG_fail;
38296 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38297 1 : if (!SWIG_IsOK(res1)) {
38298 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_maxy_get" "', argument " "1"" of type '" "rectObj *""'");
38299 : }
38300 1 : arg1 = (rectObj *)(argp1);
38301 1 : result = (double) ((arg1)->maxy);
38302 1 : resultobj = SWIG_From_double((double)(result));
38303 1 : return resultobj;
38304 0 : fail:
38305 : return NULL;
38306 : }
38307 :
38308 :
38309 1 : SWIGINTERN PyObject *_wrap_new_rectObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38310 : PyObject *resultobj = 0;
38311 : double arg1 = (double) -1.0 ;
38312 : double arg2 = (double) -1.0 ;
38313 : double arg3 = (double) -1.0 ;
38314 : double arg4 = (double) -1.0 ;
38315 : int arg5 = (int) 0 ;
38316 : double val1 ;
38317 : int ecode1 = 0 ;
38318 : double val2 ;
38319 : int ecode2 = 0 ;
38320 : double val3 ;
38321 : int ecode3 = 0 ;
38322 : double val4 ;
38323 : int ecode4 = 0 ;
38324 : int val5 ;
38325 : int ecode5 = 0 ;
38326 1 : PyObject * obj0 = 0 ;
38327 1 : PyObject * obj1 = 0 ;
38328 1 : PyObject * obj2 = 0 ;
38329 1 : PyObject * obj3 = 0 ;
38330 1 : PyObject * obj4 = 0 ;
38331 : rectObj *result = 0 ;
38332 :
38333 1 : if (!PyArg_ParseTuple(args,(char *)"|OOOOO:new_rectObj",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38334 1 : if (obj0) {
38335 1 : ecode1 = SWIG_AsVal_double(obj0, &val1);
38336 1 : if (!SWIG_IsOK(ecode1)) {
38337 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_rectObj" "', argument " "1"" of type '" "double""'");
38338 : }
38339 1 : arg1 = (double)(val1);
38340 : }
38341 1 : if (obj1) {
38342 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38343 1 : if (!SWIG_IsOK(ecode2)) {
38344 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_rectObj" "', argument " "2"" of type '" "double""'");
38345 : }
38346 1 : arg2 = (double)(val2);
38347 : }
38348 1 : if (obj2) {
38349 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
38350 1 : if (!SWIG_IsOK(ecode3)) {
38351 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_rectObj" "', argument " "3"" of type '" "double""'");
38352 : }
38353 1 : arg3 = (double)(val3);
38354 : }
38355 1 : if (obj3) {
38356 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
38357 1 : if (!SWIG_IsOK(ecode4)) {
38358 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_rectObj" "', argument " "4"" of type '" "double""'");
38359 : }
38360 1 : arg4 = (double)(val4);
38361 : }
38362 1 : if (obj4) {
38363 : ecode5 = SWIG_AsVal_int(obj4, &val5);
38364 1 : if (!SWIG_IsOK(ecode5)) {
38365 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_rectObj" "', argument " "5"" of type '" "int""'");
38366 : }
38367 : arg5 = (int)(val5);
38368 : }
38369 : {
38370 1 : result = (rectObj *)new_rectObj(arg1,arg2,arg3,arg4,arg5); {
38371 1 : errorObj *ms_error = msGetErrorObj();
38372 :
38373 1 : switch(ms_error->code) {
38374 : case MS_NOERR:
38375 : break;
38376 0 : case MS_NOTFOUND:
38377 0 : msResetErrorList();
38378 0 : break;
38379 : case -1:
38380 : break;
38381 0 : case MS_IOERR:
38382 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38383 0 : _raise_ms_exception();
38384 0 : msResetErrorList();
38385 0 : return NULL;
38386 : }
38387 : default:
38388 1 : _raise_ms_exception();
38389 1 : msResetErrorList();
38390 1 : return NULL;
38391 : }
38392 :
38393 : }
38394 : }
38395 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, SWIG_POINTER_NEW | 0 );
38396 1 : return resultobj;
38397 0 : fail:
38398 : return NULL;
38399 : }
38400 :
38401 :
38402 1 : SWIGINTERN PyObject *_wrap_delete_rectObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38403 : PyObject *resultobj = 0;
38404 : rectObj *arg1 = (rectObj *) 0 ;
38405 1 : void *argp1 = 0 ;
38406 : int res1 = 0 ;
38407 1 : PyObject * obj0 = 0 ;
38408 :
38409 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_rectObj",&obj0)) SWIG_fail;
38410 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, SWIG_POINTER_DISOWN | 0 );
38411 1 : if (!SWIG_IsOK(res1)) {
38412 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_rectObj" "', argument " "1"" of type '" "rectObj *""'");
38413 : }
38414 1 : arg1 = (rectObj *)(argp1);
38415 : {
38416 : delete_rectObj(arg1); {
38417 1 : errorObj *ms_error = msGetErrorObj();
38418 :
38419 1 : switch(ms_error->code) {
38420 : case MS_NOERR:
38421 : break;
38422 0 : case MS_NOTFOUND:
38423 0 : msResetErrorList();
38424 0 : break;
38425 : case -1:
38426 : break;
38427 0 : case MS_IOERR:
38428 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38429 0 : _raise_ms_exception();
38430 0 : msResetErrorList();
38431 0 : return NULL;
38432 : }
38433 : default:
38434 0 : _raise_ms_exception();
38435 0 : msResetErrorList();
38436 0 : return NULL;
38437 : }
38438 :
38439 : }
38440 : }
38441 : resultobj = SWIG_Py_Void();
38442 1 : return resultobj;
38443 0 : fail:
38444 : return NULL;
38445 : }
38446 :
38447 :
38448 0 : SWIGINTERN PyObject *_wrap_rectObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38449 : PyObject *resultobj = 0;
38450 : rectObj *arg1 = (rectObj *) 0 ;
38451 : projectionObj *arg2 = (projectionObj *) 0 ;
38452 : projectionObj *arg3 = (projectionObj *) 0 ;
38453 0 : void *argp1 = 0 ;
38454 : int res1 = 0 ;
38455 0 : void *argp2 = 0 ;
38456 : int res2 = 0 ;
38457 0 : void *argp3 = 0 ;
38458 : int res3 = 0 ;
38459 0 : PyObject * obj0 = 0 ;
38460 0 : PyObject * obj1 = 0 ;
38461 0 : PyObject * obj2 = 0 ;
38462 : int result;
38463 :
38464 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:rectObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
38465 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38466 0 : if (!SWIG_IsOK(res1)) {
38467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_project" "', argument " "1"" of type '" "rectObj *""'");
38468 : }
38469 0 : arg1 = (rectObj *)(argp1);
38470 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 | 0 );
38471 0 : if (!SWIG_IsOK(res2)) {
38472 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rectObj_project" "', argument " "2"" of type '" "projectionObj *""'");
38473 : }
38474 0 : arg2 = (projectionObj *)(argp2);
38475 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 | 0 );
38476 0 : if (!SWIG_IsOK(res3)) {
38477 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rectObj_project" "', argument " "3"" of type '" "projectionObj *""'");
38478 : }
38479 0 : arg3 = (projectionObj *)(argp3);
38480 : {
38481 : result = (int)rectObj_project(arg1,arg2,arg3); {
38482 0 : errorObj *ms_error = msGetErrorObj();
38483 :
38484 0 : switch(ms_error->code) {
38485 : case MS_NOERR:
38486 : break;
38487 0 : case MS_NOTFOUND:
38488 0 : msResetErrorList();
38489 0 : break;
38490 : case -1:
38491 : break;
38492 0 : case MS_IOERR:
38493 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38494 0 : _raise_ms_exception();
38495 0 : msResetErrorList();
38496 0 : return NULL;
38497 : }
38498 : default:
38499 0 : _raise_ms_exception();
38500 0 : msResetErrorList();
38501 0 : return NULL;
38502 : }
38503 :
38504 : }
38505 : }
38506 : resultobj = SWIG_From_int((int)(result));
38507 0 : return resultobj;
38508 0 : fail:
38509 : return NULL;
38510 : }
38511 :
38512 :
38513 0 : SWIGINTERN PyObject *_wrap_rectObj_fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38514 : PyObject *resultobj = 0;
38515 : rectObj *arg1 = (rectObj *) 0 ;
38516 : int arg2 ;
38517 : int arg3 ;
38518 0 : void *argp1 = 0 ;
38519 : int res1 = 0 ;
38520 : int val2 ;
38521 : int ecode2 = 0 ;
38522 : int val3 ;
38523 : int ecode3 = 0 ;
38524 0 : PyObject * obj0 = 0 ;
38525 0 : PyObject * obj1 = 0 ;
38526 0 : PyObject * obj2 = 0 ;
38527 : double result;
38528 :
38529 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:rectObj_fit",&obj0,&obj1,&obj2)) SWIG_fail;
38530 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38531 0 : if (!SWIG_IsOK(res1)) {
38532 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_fit" "', argument " "1"" of type '" "rectObj *""'");
38533 : }
38534 0 : arg1 = (rectObj *)(argp1);
38535 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
38536 0 : if (!SWIG_IsOK(ecode2)) {
38537 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "rectObj_fit" "', argument " "2"" of type '" "int""'");
38538 : }
38539 : arg2 = (int)(val2);
38540 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
38541 0 : if (!SWIG_IsOK(ecode3)) {
38542 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rectObj_fit" "', argument " "3"" of type '" "int""'");
38543 : }
38544 : arg3 = (int)(val3);
38545 : {
38546 : result = (double)rectObj_fit(arg1,arg2,arg3); {
38547 0 : errorObj *ms_error = msGetErrorObj();
38548 :
38549 0 : switch(ms_error->code) {
38550 : case MS_NOERR:
38551 : break;
38552 0 : case MS_NOTFOUND:
38553 0 : msResetErrorList();
38554 0 : break;
38555 : case -1:
38556 : break;
38557 0 : case MS_IOERR:
38558 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38559 0 : _raise_ms_exception();
38560 0 : msResetErrorList();
38561 0 : return NULL;
38562 : }
38563 : default:
38564 0 : _raise_ms_exception();
38565 0 : msResetErrorList();
38566 0 : return NULL;
38567 : }
38568 :
38569 : }
38570 : }
38571 0 : resultobj = SWIG_From_double((double)(result));
38572 0 : return resultobj;
38573 0 : fail:
38574 : return NULL;
38575 : }
38576 :
38577 :
38578 0 : SWIGINTERN PyObject *_wrap_rectObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38579 : PyObject *resultobj = 0;
38580 : rectObj *arg1 = (rectObj *) 0 ;
38581 : mapObj *arg2 = (mapObj *) 0 ;
38582 : layerObj *arg3 = (layerObj *) 0 ;
38583 : imageObj *arg4 = (imageObj *) 0 ;
38584 : int arg5 ;
38585 : char *arg6 = (char *) 0 ;
38586 0 : void *argp1 = 0 ;
38587 : int res1 = 0 ;
38588 0 : void *argp2 = 0 ;
38589 : int res2 = 0 ;
38590 0 : void *argp3 = 0 ;
38591 : int res3 = 0 ;
38592 0 : void *argp4 = 0 ;
38593 : int res4 = 0 ;
38594 : int val5 ;
38595 : int ecode5 = 0 ;
38596 : int res6 ;
38597 0 : char *buf6 = 0 ;
38598 0 : int alloc6 = 0 ;
38599 0 : PyObject * obj0 = 0 ;
38600 0 : PyObject * obj1 = 0 ;
38601 0 : PyObject * obj2 = 0 ;
38602 0 : PyObject * obj3 = 0 ;
38603 0 : PyObject * obj4 = 0 ;
38604 0 : PyObject * obj5 = 0 ;
38605 : int result;
38606 :
38607 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:rectObj_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38608 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38609 0 : if (!SWIG_IsOK(res1)) {
38610 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_draw" "', argument " "1"" of type '" "rectObj *""'");
38611 : }
38612 0 : arg1 = (rectObj *)(argp1);
38613 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
38614 0 : if (!SWIG_IsOK(res2)) {
38615 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rectObj_draw" "', argument " "2"" of type '" "mapObj *""'");
38616 : }
38617 0 : arg2 = (mapObj *)(argp2);
38618 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 | 0 );
38619 0 : if (!SWIG_IsOK(res3)) {
38620 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "rectObj_draw" "', argument " "3"" of type '" "layerObj *""'");
38621 : }
38622 0 : arg3 = (layerObj *)(argp3);
38623 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 | 0 );
38624 0 : if (!SWIG_IsOK(res4)) {
38625 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "rectObj_draw" "', argument " "4"" of type '" "imageObj *""'");
38626 : }
38627 0 : arg4 = (imageObj *)(argp4);
38628 0 : ecode5 = SWIG_AsVal_int(obj4, &val5);
38629 0 : if (!SWIG_IsOK(ecode5)) {
38630 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "rectObj_draw" "', argument " "5"" of type '" "int""'");
38631 : }
38632 : arg5 = (int)(val5);
38633 0 : res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
38634 0 : if (!SWIG_IsOK(res6)) {
38635 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "rectObj_draw" "', argument " "6"" of type '" "char *""'");
38636 : }
38637 0 : arg6 = (char *)(buf6);
38638 : {
38639 0 : result = (int)rectObj_draw(arg1,arg2,arg3,arg4,arg5,arg6); {
38640 0 : errorObj *ms_error = msGetErrorObj();
38641 :
38642 0 : switch(ms_error->code) {
38643 : case MS_NOERR:
38644 : break;
38645 0 : case MS_NOTFOUND:
38646 0 : msResetErrorList();
38647 0 : break;
38648 : case -1:
38649 : break;
38650 0 : case MS_IOERR:
38651 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38652 0 : _raise_ms_exception();
38653 0 : msResetErrorList();
38654 0 : return NULL;
38655 : }
38656 : default:
38657 0 : _raise_ms_exception();
38658 0 : msResetErrorList();
38659 0 : return NULL;
38660 : }
38661 :
38662 : }
38663 : }
38664 : resultobj = SWIG_From_int((int)(result));
38665 0 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
38666 : return resultobj;
38667 0 : fail:
38668 0 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
38669 : return NULL;
38670 : }
38671 :
38672 :
38673 0 : SWIGINTERN PyObject *_wrap_rectObj_getCenter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38674 : PyObject *resultobj = 0;
38675 : rectObj *arg1 = (rectObj *) 0 ;
38676 0 : void *argp1 = 0 ;
38677 : int res1 = 0 ;
38678 0 : PyObject * obj0 = 0 ;
38679 : pointObj *result = 0 ;
38680 :
38681 0 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_getCenter",&obj0)) SWIG_fail;
38682 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38683 0 : if (!SWIG_IsOK(res1)) {
38684 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_getCenter" "', argument " "1"" of type '" "rectObj *""'");
38685 : }
38686 0 : arg1 = (rectObj *)(argp1);
38687 : {
38688 0 : result = (pointObj *)rectObj_getCenter(arg1); {
38689 0 : errorObj *ms_error = msGetErrorObj();
38690 :
38691 0 : switch(ms_error->code) {
38692 : case MS_NOERR:
38693 : break;
38694 0 : case MS_NOTFOUND:
38695 0 : msResetErrorList();
38696 0 : break;
38697 : case -1:
38698 : break;
38699 0 : case MS_IOERR:
38700 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38701 0 : _raise_ms_exception();
38702 0 : msResetErrorList();
38703 0 : return NULL;
38704 : }
38705 : default:
38706 0 : _raise_ms_exception();
38707 0 : msResetErrorList();
38708 0 : return NULL;
38709 : }
38710 :
38711 : }
38712 : }
38713 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN | 0 );
38714 0 : return resultobj;
38715 0 : fail:
38716 : return NULL;
38717 : }
38718 :
38719 :
38720 1 : SWIGINTERN PyObject *_wrap_rectObj_toPolygon(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38721 : PyObject *resultobj = 0;
38722 : rectObj *arg1 = (rectObj *) 0 ;
38723 1 : void *argp1 = 0 ;
38724 : int res1 = 0 ;
38725 1 : PyObject * obj0 = 0 ;
38726 : shapeObj *result = 0 ;
38727 :
38728 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_toPolygon",&obj0)) SWIG_fail;
38729 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38730 1 : if (!SWIG_IsOK(res1)) {
38731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_toPolygon" "', argument " "1"" of type '" "rectObj *""'");
38732 : }
38733 1 : arg1 = (rectObj *)(argp1);
38734 : {
38735 1 : result = (shapeObj *)rectObj_toPolygon(arg1); {
38736 1 : errorObj *ms_error = msGetErrorObj();
38737 :
38738 1 : switch(ms_error->code) {
38739 : case MS_NOERR:
38740 : break;
38741 0 : case MS_NOTFOUND:
38742 0 : msResetErrorList();
38743 0 : break;
38744 : case -1:
38745 : break;
38746 0 : case MS_IOERR:
38747 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38748 0 : _raise_ms_exception();
38749 0 : msResetErrorList();
38750 0 : return NULL;
38751 : }
38752 : default:
38753 0 : _raise_ms_exception();
38754 0 : msResetErrorList();
38755 0 : return NULL;
38756 : }
38757 :
38758 : }
38759 : }
38760 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
38761 1 : return resultobj;
38762 0 : fail:
38763 : return NULL;
38764 : }
38765 :
38766 :
38767 1 : SWIGINTERN PyObject *_wrap_rectObj_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38768 : PyObject *resultobj = 0;
38769 : rectObj *arg1 = (rectObj *) 0 ;
38770 1 : void *argp1 = 0 ;
38771 : int res1 = 0 ;
38772 1 : PyObject * obj0 = 0 ;
38773 : char *result = 0 ;
38774 :
38775 1 : if (!PyArg_ParseTuple(args,(char *)"O:rectObj_toString",&obj0)) SWIG_fail;
38776 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_rectObj, 0 | 0 );
38777 1 : if (!SWIG_IsOK(res1)) {
38778 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rectObj_toString" "', argument " "1"" of type '" "rectObj *""'");
38779 : }
38780 1 : arg1 = (rectObj *)(argp1);
38781 : {
38782 1 : result = (char *)rectObj_toString(arg1); {
38783 1 : errorObj *ms_error = msGetErrorObj();
38784 :
38785 1 : switch(ms_error->code) {
38786 : case MS_NOERR:
38787 : break;
38788 0 : case MS_NOTFOUND:
38789 0 : msResetErrorList();
38790 0 : break;
38791 : case -1:
38792 : break;
38793 0 : case MS_IOERR:
38794 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38795 0 : _raise_ms_exception();
38796 0 : msResetErrorList();
38797 0 : return NULL;
38798 : }
38799 : default:
38800 0 : _raise_ms_exception();
38801 0 : msResetErrorList();
38802 0 : return NULL;
38803 : }
38804 :
38805 : }
38806 : }
38807 1 : resultobj = SWIG_FromCharPtr((const char *)result);
38808 1 : free((char*)result);
38809 1 : return resultobj;
38810 0 : fail:
38811 : return NULL;
38812 : }
38813 :
38814 :
38815 1 : SWIGINTERN PyObject *rectObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38816 : PyObject *obj;
38817 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
38818 1 : SWIG_TypeNewClientData(SWIGTYPE_p_rectObj, SWIG_NewClientData(obj));
38819 1 : return SWIG_Py_Void();
38820 : }
38821 :
38822 1 : SWIGINTERN PyObject *_wrap_pointObj_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38823 : PyObject *resultobj = 0;
38824 : pointObj *arg1 = (pointObj *) 0 ;
38825 : double arg2 ;
38826 1 : void *argp1 = 0 ;
38827 : int res1 = 0 ;
38828 : double val2 ;
38829 : int ecode2 = 0 ;
38830 1 : PyObject * obj0 = 0 ;
38831 1 : PyObject * obj1 = 0 ;
38832 :
38833 1 : if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_x_set",&obj0,&obj1)) SWIG_fail;
38834 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
38835 1 : if (!SWIG_IsOK(res1)) {
38836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_x_set" "', argument " "1"" of type '" "pointObj *""'");
38837 : }
38838 1 : arg1 = (pointObj *)(argp1);
38839 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38840 1 : if (!SWIG_IsOK(ecode2)) {
38841 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_x_set" "', argument " "2"" of type '" "double""'");
38842 : }
38843 1 : arg2 = (double)(val2);
38844 1 : if (arg1) (arg1)->x = arg2;
38845 : resultobj = SWIG_Py_Void();
38846 1 : return resultobj;
38847 0 : fail:
38848 : return NULL;
38849 : }
38850 :
38851 :
38852 1 : SWIGINTERN PyObject *_wrap_pointObj_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38853 : PyObject *resultobj = 0;
38854 : pointObj *arg1 = (pointObj *) 0 ;
38855 1 : void *argp1 = 0 ;
38856 : int res1 = 0 ;
38857 1 : PyObject * obj0 = 0 ;
38858 : double result;
38859 :
38860 1 : if (!PyArg_ParseTuple(args,(char *)"O:pointObj_x_get",&obj0)) SWIG_fail;
38861 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
38862 1 : if (!SWIG_IsOK(res1)) {
38863 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_x_get" "', argument " "1"" of type '" "pointObj *""'");
38864 : }
38865 1 : arg1 = (pointObj *)(argp1);
38866 1 : result = (double) ((arg1)->x);
38867 1 : resultobj = SWIG_From_double((double)(result));
38868 1 : return resultobj;
38869 0 : fail:
38870 : return NULL;
38871 : }
38872 :
38873 :
38874 1 : SWIGINTERN PyObject *_wrap_pointObj_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38875 : PyObject *resultobj = 0;
38876 : pointObj *arg1 = (pointObj *) 0 ;
38877 : double arg2 ;
38878 1 : void *argp1 = 0 ;
38879 : int res1 = 0 ;
38880 : double val2 ;
38881 : int ecode2 = 0 ;
38882 1 : PyObject * obj0 = 0 ;
38883 1 : PyObject * obj1 = 0 ;
38884 :
38885 1 : if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_y_set",&obj0,&obj1)) SWIG_fail;
38886 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
38887 1 : if (!SWIG_IsOK(res1)) {
38888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_y_set" "', argument " "1"" of type '" "pointObj *""'");
38889 : }
38890 1 : arg1 = (pointObj *)(argp1);
38891 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38892 1 : if (!SWIG_IsOK(ecode2)) {
38893 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_y_set" "', argument " "2"" of type '" "double""'");
38894 : }
38895 1 : arg2 = (double)(val2);
38896 1 : if (arg1) (arg1)->y = arg2;
38897 : resultobj = SWIG_Py_Void();
38898 1 : return resultobj;
38899 0 : fail:
38900 : return NULL;
38901 : }
38902 :
38903 :
38904 1 : SWIGINTERN PyObject *_wrap_pointObj_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38905 : PyObject *resultobj = 0;
38906 : pointObj *arg1 = (pointObj *) 0 ;
38907 1 : void *argp1 = 0 ;
38908 : int res1 = 0 ;
38909 1 : PyObject * obj0 = 0 ;
38910 : double result;
38911 :
38912 1 : if (!PyArg_ParseTuple(args,(char *)"O:pointObj_y_get",&obj0)) SWIG_fail;
38913 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
38914 1 : if (!SWIG_IsOK(res1)) {
38915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_y_get" "', argument " "1"" of type '" "pointObj *""'");
38916 : }
38917 1 : arg1 = (pointObj *)(argp1);
38918 1 : result = (double) ((arg1)->y);
38919 1 : resultobj = SWIG_From_double((double)(result));
38920 1 : return resultobj;
38921 0 : fail:
38922 : return NULL;
38923 : }
38924 :
38925 :
38926 1 : SWIGINTERN PyObject *_wrap_new_pointObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38927 : PyObject *resultobj = 0;
38928 : double arg1 = (double) 0.0 ;
38929 : double arg2 = (double) 0.0 ;
38930 : double arg3 = (double) 0.0 ;
38931 : double arg4 = (double) -2e38 ;
38932 : double val1 ;
38933 : int ecode1 = 0 ;
38934 : double val2 ;
38935 : int ecode2 = 0 ;
38936 : double val3 ;
38937 : int ecode3 = 0 ;
38938 : double val4 ;
38939 : int ecode4 = 0 ;
38940 1 : PyObject * obj0 = 0 ;
38941 1 : PyObject * obj1 = 0 ;
38942 1 : PyObject * obj2 = 0 ;
38943 1 : PyObject * obj3 = 0 ;
38944 : pointObj *result = 0 ;
38945 :
38946 1 : if (!PyArg_ParseTuple(args,(char *)"|OOOO:new_pointObj",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38947 1 : if (obj0) {
38948 1 : ecode1 = SWIG_AsVal_double(obj0, &val1);
38949 1 : if (!SWIG_IsOK(ecode1)) {
38950 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_pointObj" "', argument " "1"" of type '" "double""'");
38951 : }
38952 1 : arg1 = (double)(val1);
38953 : }
38954 1 : if (obj1) {
38955 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
38956 1 : if (!SWIG_IsOK(ecode2)) {
38957 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_pointObj" "', argument " "2"" of type '" "double""'");
38958 : }
38959 1 : arg2 = (double)(val2);
38960 : }
38961 1 : if (obj2) {
38962 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
38963 1 : if (!SWIG_IsOK(ecode3)) {
38964 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_pointObj" "', argument " "3"" of type '" "double""'");
38965 : }
38966 : arg3 = (double)(val3);
38967 : }
38968 1 : if (obj3) {
38969 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
38970 1 : if (!SWIG_IsOK(ecode4)) {
38971 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_pointObj" "', argument " "4"" of type '" "double""'");
38972 : }
38973 : arg4 = (double)(val4);
38974 : }
38975 : {
38976 : result = (pointObj *)new_pointObj(arg1,arg2,arg3,arg4); {
38977 1 : errorObj *ms_error = msGetErrorObj();
38978 :
38979 1 : switch(ms_error->code) {
38980 : case MS_NOERR:
38981 : break;
38982 0 : case MS_NOTFOUND:
38983 0 : msResetErrorList();
38984 0 : break;
38985 : case -1:
38986 : break;
38987 0 : case MS_IOERR:
38988 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
38989 0 : _raise_ms_exception();
38990 0 : msResetErrorList();
38991 0 : return NULL;
38992 : }
38993 : default:
38994 0 : _raise_ms_exception();
38995 0 : msResetErrorList();
38996 0 : return NULL;
38997 : }
38998 :
38999 : }
39000 : }
39001 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_NEW | 0 );
39002 1 : return resultobj;
39003 0 : fail:
39004 : return NULL;
39005 : }
39006 :
39007 :
39008 1 : SWIGINTERN PyObject *_wrap_delete_pointObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39009 : PyObject *resultobj = 0;
39010 : pointObj *arg1 = (pointObj *) 0 ;
39011 1 : void *argp1 = 0 ;
39012 : int res1 = 0 ;
39013 1 : PyObject * obj0 = 0 ;
39014 :
39015 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_pointObj",&obj0)) SWIG_fail;
39016 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, SWIG_POINTER_DISOWN | 0 );
39017 1 : if (!SWIG_IsOK(res1)) {
39018 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_pointObj" "', argument " "1"" of type '" "pointObj *""'");
39019 : }
39020 1 : arg1 = (pointObj *)(argp1);
39021 : {
39022 : delete_pointObj(arg1); {
39023 1 : errorObj *ms_error = msGetErrorObj();
39024 :
39025 1 : switch(ms_error->code) {
39026 : case MS_NOERR:
39027 : break;
39028 0 : case MS_NOTFOUND:
39029 0 : msResetErrorList();
39030 0 : break;
39031 : case -1:
39032 : break;
39033 0 : case MS_IOERR:
39034 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39035 0 : _raise_ms_exception();
39036 0 : msResetErrorList();
39037 0 : return NULL;
39038 : }
39039 : default:
39040 0 : _raise_ms_exception();
39041 0 : msResetErrorList();
39042 0 : return NULL;
39043 : }
39044 :
39045 : }
39046 : }
39047 : resultobj = SWIG_Py_Void();
39048 1 : return resultobj;
39049 0 : fail:
39050 : return NULL;
39051 : }
39052 :
39053 :
39054 1 : SWIGINTERN PyObject *_wrap_pointObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39055 : PyObject *resultobj = 0;
39056 : pointObj *arg1 = (pointObj *) 0 ;
39057 : projectionObj *arg2 = (projectionObj *) 0 ;
39058 : projectionObj *arg3 = (projectionObj *) 0 ;
39059 1 : void *argp1 = 0 ;
39060 : int res1 = 0 ;
39061 1 : void *argp2 = 0 ;
39062 : int res2 = 0 ;
39063 1 : void *argp3 = 0 ;
39064 : int res3 = 0 ;
39065 1 : PyObject * obj0 = 0 ;
39066 1 : PyObject * obj1 = 0 ;
39067 1 : PyObject * obj2 = 0 ;
39068 : int result;
39069 :
39070 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:pointObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
39071 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39072 1 : if (!SWIG_IsOK(res1)) {
39073 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_project" "', argument " "1"" of type '" "pointObj *""'");
39074 : }
39075 1 : arg1 = (pointObj *)(argp1);
39076 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 | 0 );
39077 1 : if (!SWIG_IsOK(res2)) {
39078 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_project" "', argument " "2"" of type '" "projectionObj *""'");
39079 : }
39080 1 : arg2 = (projectionObj *)(argp2);
39081 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 | 0 );
39082 1 : if (!SWIG_IsOK(res3)) {
39083 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_project" "', argument " "3"" of type '" "projectionObj *""'");
39084 : }
39085 1 : arg3 = (projectionObj *)(argp3);
39086 : {
39087 : result = (int)pointObj_project(arg1,arg2,arg3); {
39088 1 : errorObj *ms_error = msGetErrorObj();
39089 :
39090 1 : switch(ms_error->code) {
39091 : case MS_NOERR:
39092 : break;
39093 0 : case MS_NOTFOUND:
39094 0 : msResetErrorList();
39095 0 : break;
39096 : case -1:
39097 : break;
39098 0 : case MS_IOERR:
39099 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39100 0 : _raise_ms_exception();
39101 0 : msResetErrorList();
39102 0 : return NULL;
39103 : }
39104 : default:
39105 0 : _raise_ms_exception();
39106 0 : msResetErrorList();
39107 0 : return NULL;
39108 : }
39109 :
39110 : }
39111 : }
39112 : resultobj = SWIG_From_int((int)(result));
39113 1 : return resultobj;
39114 0 : fail:
39115 : return NULL;
39116 : }
39117 :
39118 :
39119 1 : SWIGINTERN PyObject *_wrap_pointObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39120 : PyObject *resultobj = 0;
39121 : pointObj *arg1 = (pointObj *) 0 ;
39122 : mapObj *arg2 = (mapObj *) 0 ;
39123 : layerObj *arg3 = (layerObj *) 0 ;
39124 : imageObj *arg4 = (imageObj *) 0 ;
39125 : int arg5 ;
39126 : char *arg6 = (char *) 0 ;
39127 1 : void *argp1 = 0 ;
39128 : int res1 = 0 ;
39129 1 : void *argp2 = 0 ;
39130 : int res2 = 0 ;
39131 1 : void *argp3 = 0 ;
39132 : int res3 = 0 ;
39133 1 : void *argp4 = 0 ;
39134 : int res4 = 0 ;
39135 : int val5 ;
39136 : int ecode5 = 0 ;
39137 : int res6 ;
39138 1 : char *buf6 = 0 ;
39139 1 : int alloc6 = 0 ;
39140 1 : PyObject * obj0 = 0 ;
39141 1 : PyObject * obj1 = 0 ;
39142 1 : PyObject * obj2 = 0 ;
39143 1 : PyObject * obj3 = 0 ;
39144 1 : PyObject * obj4 = 0 ;
39145 1 : PyObject * obj5 = 0 ;
39146 : int result;
39147 :
39148 1 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:pointObj_draw",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39149 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39150 1 : if (!SWIG_IsOK(res1)) {
39151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_draw" "', argument " "1"" of type '" "pointObj *""'");
39152 : }
39153 1 : arg1 = (pointObj *)(argp1);
39154 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
39155 1 : if (!SWIG_IsOK(res2)) {
39156 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_draw" "', argument " "2"" of type '" "mapObj *""'");
39157 : }
39158 1 : arg2 = (mapObj *)(argp2);
39159 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 | 0 );
39160 1 : if (!SWIG_IsOK(res3)) {
39161 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_draw" "', argument " "3"" of type '" "layerObj *""'");
39162 : }
39163 1 : arg3 = (layerObj *)(argp3);
39164 1 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 | 0 );
39165 1 : if (!SWIG_IsOK(res4)) {
39166 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "pointObj_draw" "', argument " "4"" of type '" "imageObj *""'");
39167 : }
39168 1 : arg4 = (imageObj *)(argp4);
39169 1 : ecode5 = SWIG_AsVal_int(obj4, &val5);
39170 1 : if (!SWIG_IsOK(ecode5)) {
39171 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_draw" "', argument " "5"" of type '" "int""'");
39172 : }
39173 : arg5 = (int)(val5);
39174 1 : res6 = SWIG_AsCharPtrAndSize(obj5, &buf6, NULL, &alloc6);
39175 1 : if (!SWIG_IsOK(res6)) {
39176 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "pointObj_draw" "', argument " "6"" of type '" "char *""'");
39177 : }
39178 1 : arg6 = (char *)(buf6);
39179 : {
39180 : result = (int)pointObj_draw(arg1,arg2,arg3,arg4,arg5,arg6); {
39181 1 : errorObj *ms_error = msGetErrorObj();
39182 :
39183 1 : switch(ms_error->code) {
39184 : case MS_NOERR:
39185 : break;
39186 0 : case MS_NOTFOUND:
39187 0 : msResetErrorList();
39188 0 : break;
39189 : case -1:
39190 : break;
39191 0 : case MS_IOERR:
39192 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39193 0 : _raise_ms_exception();
39194 0 : msResetErrorList();
39195 0 : return NULL;
39196 : }
39197 : default:
39198 0 : _raise_ms_exception();
39199 0 : msResetErrorList();
39200 0 : return NULL;
39201 : }
39202 :
39203 : }
39204 : }
39205 : resultobj = SWIG_From_int((int)(result));
39206 1 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
39207 : return resultobj;
39208 0 : fail:
39209 0 : if (alloc6 == SWIG_NEWOBJ) free((char*)buf6);
39210 : return NULL;
39211 : }
39212 :
39213 :
39214 0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39215 : PyObject *resultobj = 0;
39216 : pointObj *arg1 = (pointObj *) 0 ;
39217 : pointObj *arg2 = (pointObj *) 0 ;
39218 0 : void *argp1 = 0 ;
39219 : int res1 = 0 ;
39220 0 : void *argp2 = 0 ;
39221 : int res2 = 0 ;
39222 0 : PyObject * obj0 = 0 ;
39223 0 : PyObject * obj1 = 0 ;
39224 : double result;
39225 :
39226 0 : if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_distanceToPoint",&obj0,&obj1)) SWIG_fail;
39227 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39228 0 : if (!SWIG_IsOK(res1)) {
39229 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToPoint" "', argument " "1"" of type '" "pointObj *""'");
39230 : }
39231 0 : arg1 = (pointObj *)(argp1);
39232 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
39233 0 : if (!SWIG_IsOK(res2)) {
39234 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToPoint" "', argument " "2"" of type '" "pointObj *""'");
39235 : }
39236 0 : arg2 = (pointObj *)(argp2);
39237 : {
39238 : result = (double)pointObj_distanceToPoint(arg1,arg2); {
39239 0 : errorObj *ms_error = msGetErrorObj();
39240 :
39241 0 : switch(ms_error->code) {
39242 : case MS_NOERR:
39243 : break;
39244 0 : case MS_NOTFOUND:
39245 0 : msResetErrorList();
39246 0 : break;
39247 : case -1:
39248 : break;
39249 0 : case MS_IOERR:
39250 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39251 0 : _raise_ms_exception();
39252 0 : msResetErrorList();
39253 0 : return NULL;
39254 : }
39255 : default:
39256 0 : _raise_ms_exception();
39257 0 : msResetErrorList();
39258 0 : return NULL;
39259 : }
39260 :
39261 : }
39262 : }
39263 0 : resultobj = SWIG_From_double((double)(result));
39264 0 : return resultobj;
39265 0 : fail:
39266 : return NULL;
39267 : }
39268 :
39269 :
39270 0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToSegment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39271 : PyObject *resultobj = 0;
39272 : pointObj *arg1 = (pointObj *) 0 ;
39273 : pointObj *arg2 = (pointObj *) 0 ;
39274 : pointObj *arg3 = (pointObj *) 0 ;
39275 0 : void *argp1 = 0 ;
39276 : int res1 = 0 ;
39277 0 : void *argp2 = 0 ;
39278 : int res2 = 0 ;
39279 0 : void *argp3 = 0 ;
39280 : int res3 = 0 ;
39281 0 : PyObject * obj0 = 0 ;
39282 0 : PyObject * obj1 = 0 ;
39283 0 : PyObject * obj2 = 0 ;
39284 : double result;
39285 :
39286 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:pointObj_distanceToSegment",&obj0,&obj1,&obj2)) SWIG_fail;
39287 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39288 0 : if (!SWIG_IsOK(res1)) {
39289 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToSegment" "', argument " "1"" of type '" "pointObj *""'");
39290 : }
39291 0 : arg1 = (pointObj *)(argp1);
39292 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
39293 0 : if (!SWIG_IsOK(res2)) {
39294 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToSegment" "', argument " "2"" of type '" "pointObj *""'");
39295 : }
39296 0 : arg2 = (pointObj *)(argp2);
39297 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
39298 0 : if (!SWIG_IsOK(res3)) {
39299 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "pointObj_distanceToSegment" "', argument " "3"" of type '" "pointObj *""'");
39300 : }
39301 0 : arg3 = (pointObj *)(argp3);
39302 : {
39303 : result = (double)pointObj_distanceToSegment(arg1,arg2,arg3); {
39304 0 : errorObj *ms_error = msGetErrorObj();
39305 :
39306 0 : switch(ms_error->code) {
39307 : case MS_NOERR:
39308 : break;
39309 0 : case MS_NOTFOUND:
39310 0 : msResetErrorList();
39311 0 : break;
39312 : case -1:
39313 : break;
39314 0 : case MS_IOERR:
39315 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39316 0 : _raise_ms_exception();
39317 0 : msResetErrorList();
39318 0 : return NULL;
39319 : }
39320 : default:
39321 0 : _raise_ms_exception();
39322 0 : msResetErrorList();
39323 0 : return NULL;
39324 : }
39325 :
39326 : }
39327 : }
39328 0 : resultobj = SWIG_From_double((double)(result));
39329 0 : return resultobj;
39330 0 : fail:
39331 : return NULL;
39332 : }
39333 :
39334 :
39335 0 : SWIGINTERN PyObject *_wrap_pointObj_distanceToShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39336 : PyObject *resultobj = 0;
39337 : pointObj *arg1 = (pointObj *) 0 ;
39338 : shapeObj *arg2 = (shapeObj *) 0 ;
39339 0 : void *argp1 = 0 ;
39340 : int res1 = 0 ;
39341 0 : void *argp2 = 0 ;
39342 : int res2 = 0 ;
39343 0 : PyObject * obj0 = 0 ;
39344 0 : PyObject * obj1 = 0 ;
39345 : double result;
39346 :
39347 0 : if (!PyArg_ParseTuple(args,(char *)"OO:pointObj_distanceToShape",&obj0,&obj1)) SWIG_fail;
39348 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39349 0 : if (!SWIG_IsOK(res1)) {
39350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_distanceToShape" "', argument " "1"" of type '" "pointObj *""'");
39351 : }
39352 0 : arg1 = (pointObj *)(argp1);
39353 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
39354 0 : if (!SWIG_IsOK(res2)) {
39355 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "pointObj_distanceToShape" "', argument " "2"" of type '" "shapeObj *""'");
39356 : }
39357 0 : arg2 = (shapeObj *)(argp2);
39358 : {
39359 : result = (double)pointObj_distanceToShape(arg1,arg2); {
39360 0 : errorObj *ms_error = msGetErrorObj();
39361 :
39362 0 : switch(ms_error->code) {
39363 : case MS_NOERR:
39364 : break;
39365 0 : case MS_NOTFOUND:
39366 0 : msResetErrorList();
39367 0 : break;
39368 : case -1:
39369 : break;
39370 0 : case MS_IOERR:
39371 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39372 0 : _raise_ms_exception();
39373 0 : msResetErrorList();
39374 0 : return NULL;
39375 : }
39376 : default:
39377 0 : _raise_ms_exception();
39378 0 : msResetErrorList();
39379 0 : return NULL;
39380 : }
39381 :
39382 : }
39383 : }
39384 0 : resultobj = SWIG_From_double((double)(result));
39385 0 : return resultobj;
39386 0 : fail:
39387 : return NULL;
39388 : }
39389 :
39390 :
39391 1 : SWIGINTERN PyObject *_wrap_pointObj_setXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39392 : PyObject *resultobj = 0;
39393 : pointObj *arg1 = (pointObj *) 0 ;
39394 : double arg2 ;
39395 : double arg3 ;
39396 : double arg4 = (double) -2e38 ;
39397 1 : void *argp1 = 0 ;
39398 : int res1 = 0 ;
39399 : double val2 ;
39400 : int ecode2 = 0 ;
39401 : double val3 ;
39402 : int ecode3 = 0 ;
39403 : double val4 ;
39404 : int ecode4 = 0 ;
39405 1 : PyObject * obj0 = 0 ;
39406 1 : PyObject * obj1 = 0 ;
39407 1 : PyObject * obj2 = 0 ;
39408 1 : PyObject * obj3 = 0 ;
39409 : int result;
39410 :
39411 1 : if (!PyArg_ParseTuple(args,(char *)"OOO|O:pointObj_setXY",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39412 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39413 1 : if (!SWIG_IsOK(res1)) {
39414 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXY" "', argument " "1"" of type '" "pointObj *""'");
39415 : }
39416 1 : arg1 = (pointObj *)(argp1);
39417 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
39418 1 : if (!SWIG_IsOK(ecode2)) {
39419 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXY" "', argument " "2"" of type '" "double""'");
39420 : }
39421 1 : arg2 = (double)(val2);
39422 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
39423 1 : if (!SWIG_IsOK(ecode3)) {
39424 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXY" "', argument " "3"" of type '" "double""'");
39425 : }
39426 1 : arg3 = (double)(val3);
39427 1 : if (obj3) {
39428 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
39429 1 : if (!SWIG_IsOK(ecode4)) {
39430 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXY" "', argument " "4"" of type '" "double""'");
39431 : }
39432 : arg4 = (double)(val4);
39433 : }
39434 : {
39435 : result = (int)pointObj_setXY(arg1,arg2,arg3,arg4); {
39436 1 : errorObj *ms_error = msGetErrorObj();
39437 :
39438 1 : switch(ms_error->code) {
39439 : case MS_NOERR:
39440 : break;
39441 0 : case MS_NOTFOUND:
39442 0 : msResetErrorList();
39443 0 : break;
39444 : case -1:
39445 : break;
39446 0 : case MS_IOERR:
39447 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39448 0 : _raise_ms_exception();
39449 0 : msResetErrorList();
39450 0 : return NULL;
39451 : }
39452 : default:
39453 0 : _raise_ms_exception();
39454 0 : msResetErrorList();
39455 0 : return NULL;
39456 : }
39457 :
39458 : }
39459 : }
39460 : resultobj = SWIG_From_int((int)(result));
39461 1 : return resultobj;
39462 0 : fail:
39463 : return NULL;
39464 : }
39465 :
39466 :
39467 1 : SWIGINTERN PyObject *_wrap_pointObj_setXYZ(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39468 : PyObject *resultobj = 0;
39469 : pointObj *arg1 = (pointObj *) 0 ;
39470 : double arg2 ;
39471 : double arg3 ;
39472 : double arg4 ;
39473 : double arg5 = (double) -2e38 ;
39474 1 : void *argp1 = 0 ;
39475 : int res1 = 0 ;
39476 : double val2 ;
39477 : int ecode2 = 0 ;
39478 : double val3 ;
39479 : int ecode3 = 0 ;
39480 : double val4 ;
39481 : int ecode4 = 0 ;
39482 : double val5 ;
39483 : int ecode5 = 0 ;
39484 1 : PyObject * obj0 = 0 ;
39485 1 : PyObject * obj1 = 0 ;
39486 1 : PyObject * obj2 = 0 ;
39487 1 : PyObject * obj3 = 0 ;
39488 1 : PyObject * obj4 = 0 ;
39489 : int result;
39490 :
39491 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO|O:pointObj_setXYZ",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39492 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39493 1 : if (!SWIG_IsOK(res1)) {
39494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXYZ" "', argument " "1"" of type '" "pointObj *""'");
39495 : }
39496 1 : arg1 = (pointObj *)(argp1);
39497 1 : ecode2 = SWIG_AsVal_double(obj1, &val2);
39498 1 : if (!SWIG_IsOK(ecode2)) {
39499 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXYZ" "', argument " "2"" of type '" "double""'");
39500 : }
39501 1 : arg2 = (double)(val2);
39502 1 : ecode3 = SWIG_AsVal_double(obj2, &val3);
39503 1 : if (!SWIG_IsOK(ecode3)) {
39504 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXYZ" "', argument " "3"" of type '" "double""'");
39505 : }
39506 1 : arg3 = (double)(val3);
39507 1 : ecode4 = SWIG_AsVal_double(obj3, &val4);
39508 1 : if (!SWIG_IsOK(ecode4)) {
39509 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXYZ" "', argument " "4"" of type '" "double""'");
39510 : }
39511 : arg4 = (double)(val4);
39512 1 : if (obj4) {
39513 1 : ecode5 = SWIG_AsVal_double(obj4, &val5);
39514 1 : if (!SWIG_IsOK(ecode5)) {
39515 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_setXYZ" "', argument " "5"" of type '" "double""'");
39516 : }
39517 : arg5 = (double)(val5);
39518 : }
39519 : {
39520 : result = (int)pointObj_setXYZ(arg1,arg2,arg3,arg4,arg5); {
39521 1 : errorObj *ms_error = msGetErrorObj();
39522 :
39523 1 : switch(ms_error->code) {
39524 : case MS_NOERR:
39525 : break;
39526 0 : case MS_NOTFOUND:
39527 0 : msResetErrorList();
39528 0 : break;
39529 : case -1:
39530 : break;
39531 0 : case MS_IOERR:
39532 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39533 0 : _raise_ms_exception();
39534 0 : msResetErrorList();
39535 0 : return NULL;
39536 : }
39537 : default:
39538 0 : _raise_ms_exception();
39539 0 : msResetErrorList();
39540 0 : return NULL;
39541 : }
39542 :
39543 : }
39544 : }
39545 : resultobj = SWIG_From_int((int)(result));
39546 1 : return resultobj;
39547 0 : fail:
39548 : return NULL;
39549 : }
39550 :
39551 :
39552 0 : SWIGINTERN PyObject *_wrap_pointObj_setXYZM(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39553 : PyObject *resultobj = 0;
39554 : pointObj *arg1 = (pointObj *) 0 ;
39555 : double arg2 ;
39556 : double arg3 ;
39557 : double arg4 ;
39558 : double arg5 ;
39559 0 : void *argp1 = 0 ;
39560 : int res1 = 0 ;
39561 : double val2 ;
39562 : int ecode2 = 0 ;
39563 : double val3 ;
39564 : int ecode3 = 0 ;
39565 : double val4 ;
39566 : int ecode4 = 0 ;
39567 : double val5 ;
39568 : int ecode5 = 0 ;
39569 0 : PyObject * obj0 = 0 ;
39570 0 : PyObject * obj1 = 0 ;
39571 0 : PyObject * obj2 = 0 ;
39572 0 : PyObject * obj3 = 0 ;
39573 0 : PyObject * obj4 = 0 ;
39574 : int result;
39575 :
39576 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:pointObj_setXYZM",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39577 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39578 0 : if (!SWIG_IsOK(res1)) {
39579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_setXYZM" "', argument " "1"" of type '" "pointObj *""'");
39580 : }
39581 0 : arg1 = (pointObj *)(argp1);
39582 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
39583 0 : if (!SWIG_IsOK(ecode2)) {
39584 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "pointObj_setXYZM" "', argument " "2"" of type '" "double""'");
39585 : }
39586 0 : arg2 = (double)(val2);
39587 0 : ecode3 = SWIG_AsVal_double(obj2, &val3);
39588 0 : if (!SWIG_IsOK(ecode3)) {
39589 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "pointObj_setXYZM" "', argument " "3"" of type '" "double""'");
39590 : }
39591 0 : arg3 = (double)(val3);
39592 0 : ecode4 = SWIG_AsVal_double(obj3, &val4);
39593 0 : if (!SWIG_IsOK(ecode4)) {
39594 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "pointObj_setXYZM" "', argument " "4"" of type '" "double""'");
39595 : }
39596 : arg4 = (double)(val4);
39597 0 : ecode5 = SWIG_AsVal_double(obj4, &val5);
39598 0 : if (!SWIG_IsOK(ecode5)) {
39599 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "pointObj_setXYZM" "', argument " "5"" of type '" "double""'");
39600 : }
39601 : arg5 = (double)(val5);
39602 : {
39603 : result = (int)pointObj_setXYZM(arg1,arg2,arg3,arg4,arg5); {
39604 0 : errorObj *ms_error = msGetErrorObj();
39605 :
39606 0 : switch(ms_error->code) {
39607 : case MS_NOERR:
39608 : break;
39609 0 : case MS_NOTFOUND:
39610 0 : msResetErrorList();
39611 0 : break;
39612 : case -1:
39613 : break;
39614 0 : case MS_IOERR:
39615 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39616 0 : _raise_ms_exception();
39617 0 : msResetErrorList();
39618 0 : return NULL;
39619 : }
39620 : default:
39621 0 : _raise_ms_exception();
39622 0 : msResetErrorList();
39623 0 : return NULL;
39624 : }
39625 :
39626 : }
39627 : }
39628 : resultobj = SWIG_From_int((int)(result));
39629 0 : return resultobj;
39630 0 : fail:
39631 : return NULL;
39632 : }
39633 :
39634 :
39635 1 : SWIGINTERN PyObject *_wrap_pointObj_toString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39636 : PyObject *resultobj = 0;
39637 : pointObj *arg1 = (pointObj *) 0 ;
39638 1 : void *argp1 = 0 ;
39639 : int res1 = 0 ;
39640 1 : PyObject * obj0 = 0 ;
39641 : char *result = 0 ;
39642 :
39643 1 : if (!PyArg_ParseTuple(args,(char *)"O:pointObj_toString",&obj0)) SWIG_fail;
39644 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39645 1 : if (!SWIG_IsOK(res1)) {
39646 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_toString" "', argument " "1"" of type '" "pointObj *""'");
39647 : }
39648 1 : arg1 = (pointObj *)(argp1);
39649 : {
39650 1 : result = (char *)pointObj_toString(arg1); {
39651 1 : errorObj *ms_error = msGetErrorObj();
39652 :
39653 1 : switch(ms_error->code) {
39654 : case MS_NOERR:
39655 : break;
39656 0 : case MS_NOTFOUND:
39657 0 : msResetErrorList();
39658 0 : break;
39659 : case -1:
39660 : break;
39661 0 : case MS_IOERR:
39662 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39663 0 : _raise_ms_exception();
39664 0 : msResetErrorList();
39665 0 : return NULL;
39666 : }
39667 : default:
39668 0 : _raise_ms_exception();
39669 0 : msResetErrorList();
39670 0 : return NULL;
39671 : }
39672 :
39673 : }
39674 : }
39675 1 : resultobj = SWIG_FromCharPtr((const char *)result);
39676 1 : free((char*)result);
39677 1 : return resultobj;
39678 0 : fail:
39679 : return NULL;
39680 : }
39681 :
39682 :
39683 0 : SWIGINTERN PyObject *_wrap_pointObj_toShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39684 : PyObject *resultobj = 0;
39685 : pointObj *arg1 = (pointObj *) 0 ;
39686 0 : void *argp1 = 0 ;
39687 : int res1 = 0 ;
39688 0 : PyObject * obj0 = 0 ;
39689 : shapeObj *result = 0 ;
39690 :
39691 0 : if (!PyArg_ParseTuple(args,(char *)"O:pointObj_toShape",&obj0)) SWIG_fail;
39692 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_pointObj, 0 | 0 );
39693 0 : if (!SWIG_IsOK(res1)) {
39694 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "pointObj_toShape" "', argument " "1"" of type '" "pointObj *""'");
39695 : }
39696 0 : arg1 = (pointObj *)(argp1);
39697 : {
39698 0 : result = (shapeObj *)pointObj_toShape(arg1); {
39699 0 : errorObj *ms_error = msGetErrorObj();
39700 :
39701 0 : switch(ms_error->code) {
39702 : case MS_NOERR:
39703 : break;
39704 0 : case MS_NOTFOUND:
39705 0 : msResetErrorList();
39706 0 : break;
39707 : case -1:
39708 : break;
39709 0 : case MS_IOERR:
39710 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39711 0 : _raise_ms_exception();
39712 0 : msResetErrorList();
39713 0 : return NULL;
39714 : }
39715 : default:
39716 0 : _raise_ms_exception();
39717 0 : msResetErrorList();
39718 0 : return NULL;
39719 : }
39720 :
39721 : }
39722 : }
39723 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
39724 0 : return resultobj;
39725 0 : fail:
39726 : return NULL;
39727 : }
39728 :
39729 :
39730 1 : SWIGINTERN PyObject *pointObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39731 : PyObject *obj;
39732 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
39733 1 : SWIG_TypeNewClientData(SWIGTYPE_p_pointObj, SWIG_NewClientData(obj));
39734 1 : return SWIG_Py_Void();
39735 : }
39736 :
39737 1 : SWIGINTERN PyObject *_wrap_lineObj_numpoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39738 : PyObject *resultobj = 0;
39739 : lineObj *arg1 = (lineObj *) 0 ;
39740 1 : void *argp1 = 0 ;
39741 : int res1 = 0 ;
39742 1 : PyObject * obj0 = 0 ;
39743 : int result;
39744 :
39745 1 : if (!PyArg_ParseTuple(args,(char *)"O:lineObj_numpoints_get",&obj0)) SWIG_fail;
39746 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 | 0 );
39747 1 : if (!SWIG_IsOK(res1)) {
39748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_numpoints_get" "', argument " "1"" of type '" "lineObj *""'");
39749 : }
39750 1 : arg1 = (lineObj *)(argp1);
39751 1 : result = (int) ((arg1)->numpoints);
39752 : resultobj = SWIG_From_int((int)(result));
39753 1 : return resultobj;
39754 0 : fail:
39755 : return NULL;
39756 : }
39757 :
39758 :
39759 1 : SWIGINTERN PyObject *_wrap_new_lineObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39760 : PyObject *resultobj = 0;
39761 : lineObj *result = 0 ;
39762 :
39763 1 : if (!PyArg_ParseTuple(args,(char *)":new_lineObj")) SWIG_fail;
39764 : {
39765 : result = (lineObj *)new_lineObj(); {
39766 1 : errorObj *ms_error = msGetErrorObj();
39767 :
39768 1 : switch(ms_error->code) {
39769 : case MS_NOERR:
39770 : break;
39771 0 : case MS_NOTFOUND:
39772 0 : msResetErrorList();
39773 0 : break;
39774 : case -1:
39775 : break;
39776 0 : case MS_IOERR:
39777 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39778 0 : _raise_ms_exception();
39779 0 : msResetErrorList();
39780 0 : return NULL;
39781 : }
39782 : default:
39783 0 : _raise_ms_exception();
39784 0 : msResetErrorList();
39785 0 : return NULL;
39786 : }
39787 :
39788 : }
39789 : }
39790 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, SWIG_POINTER_NEW | 0 );
39791 1 : return resultobj;
39792 1 : fail:
39793 : return NULL;
39794 : }
39795 :
39796 :
39797 1 : SWIGINTERN PyObject *_wrap_delete_lineObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39798 : PyObject *resultobj = 0;
39799 : lineObj *arg1 = (lineObj *) 0 ;
39800 1 : void *argp1 = 0 ;
39801 : int res1 = 0 ;
39802 1 : PyObject * obj0 = 0 ;
39803 :
39804 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_lineObj",&obj0)) SWIG_fail;
39805 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, SWIG_POINTER_DISOWN | 0 );
39806 1 : if (!SWIG_IsOK(res1)) {
39807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_lineObj" "', argument " "1"" of type '" "lineObj *""'");
39808 : }
39809 1 : arg1 = (lineObj *)(argp1);
39810 : {
39811 : delete_lineObj(arg1); {
39812 1 : errorObj *ms_error = msGetErrorObj();
39813 :
39814 1 : switch(ms_error->code) {
39815 : case MS_NOERR:
39816 : break;
39817 0 : case MS_NOTFOUND:
39818 0 : msResetErrorList();
39819 0 : break;
39820 : case -1:
39821 : break;
39822 0 : case MS_IOERR:
39823 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39824 0 : _raise_ms_exception();
39825 0 : msResetErrorList();
39826 0 : return NULL;
39827 : }
39828 : default:
39829 0 : _raise_ms_exception();
39830 0 : msResetErrorList();
39831 0 : return NULL;
39832 : }
39833 :
39834 : }
39835 : }
39836 : resultobj = SWIG_Py_Void();
39837 1 : return resultobj;
39838 0 : fail:
39839 : return NULL;
39840 : }
39841 :
39842 :
39843 0 : SWIGINTERN PyObject *_wrap_lineObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39844 : PyObject *resultobj = 0;
39845 : lineObj *arg1 = (lineObj *) 0 ;
39846 : projectionObj *arg2 = (projectionObj *) 0 ;
39847 : projectionObj *arg3 = (projectionObj *) 0 ;
39848 0 : void *argp1 = 0 ;
39849 : int res1 = 0 ;
39850 0 : void *argp2 = 0 ;
39851 : int res2 = 0 ;
39852 0 : void *argp3 = 0 ;
39853 : int res3 = 0 ;
39854 0 : PyObject * obj0 = 0 ;
39855 0 : PyObject * obj1 = 0 ;
39856 0 : PyObject * obj2 = 0 ;
39857 : int result;
39858 :
39859 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:lineObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
39860 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 | 0 );
39861 0 : if (!SWIG_IsOK(res1)) {
39862 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_project" "', argument " "1"" of type '" "lineObj *""'");
39863 : }
39864 0 : arg1 = (lineObj *)(argp1);
39865 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 | 0 );
39866 0 : if (!SWIG_IsOK(res2)) {
39867 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lineObj_project" "', argument " "2"" of type '" "projectionObj *""'");
39868 : }
39869 0 : arg2 = (projectionObj *)(argp2);
39870 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 | 0 );
39871 0 : if (!SWIG_IsOK(res3)) {
39872 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lineObj_project" "', argument " "3"" of type '" "projectionObj *""'");
39873 : }
39874 0 : arg3 = (projectionObj *)(argp3);
39875 : {
39876 : result = (int)lineObj_project(arg1,arg2,arg3); {
39877 0 : errorObj *ms_error = msGetErrorObj();
39878 :
39879 0 : switch(ms_error->code) {
39880 : case MS_NOERR:
39881 : break;
39882 0 : case MS_NOTFOUND:
39883 0 : msResetErrorList();
39884 0 : break;
39885 : case -1:
39886 : break;
39887 0 : case MS_IOERR:
39888 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39889 0 : _raise_ms_exception();
39890 0 : msResetErrorList();
39891 0 : return NULL;
39892 : }
39893 : default:
39894 0 : _raise_ms_exception();
39895 0 : msResetErrorList();
39896 0 : return NULL;
39897 : }
39898 :
39899 : }
39900 : }
39901 : resultobj = SWIG_From_int((int)(result));
39902 0 : return resultobj;
39903 0 : fail:
39904 : return NULL;
39905 : }
39906 :
39907 :
39908 1 : SWIGINTERN PyObject *_wrap_lineObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39909 : PyObject *resultobj = 0;
39910 : lineObj *arg1 = (lineObj *) 0 ;
39911 : int arg2 ;
39912 1 : void *argp1 = 0 ;
39913 : int res1 = 0 ;
39914 : int val2 ;
39915 : int ecode2 = 0 ;
39916 1 : PyObject * obj0 = 0 ;
39917 1 : PyObject * obj1 = 0 ;
39918 : pointObj *result = 0 ;
39919 :
39920 1 : if (!PyArg_ParseTuple(args,(char *)"OO:lineObj_get",&obj0,&obj1)) SWIG_fail;
39921 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 | 0 );
39922 1 : if (!SWIG_IsOK(res1)) {
39923 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_get" "', argument " "1"" of type '" "lineObj *""'");
39924 : }
39925 1 : arg1 = (lineObj *)(argp1);
39926 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
39927 1 : if (!SWIG_IsOK(ecode2)) {
39928 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lineObj_get" "', argument " "2"" of type '" "int""'");
39929 : }
39930 : arg2 = (int)(val2);
39931 : {
39932 : result = (pointObj *)lineObj_get(arg1,arg2); {
39933 1 : errorObj *ms_error = msGetErrorObj();
39934 :
39935 1 : switch(ms_error->code) {
39936 : case MS_NOERR:
39937 : break;
39938 0 : case MS_NOTFOUND:
39939 0 : msResetErrorList();
39940 0 : break;
39941 : case -1:
39942 : break;
39943 0 : case MS_IOERR:
39944 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
39945 0 : _raise_ms_exception();
39946 0 : msResetErrorList();
39947 0 : return NULL;
39948 : }
39949 : default:
39950 0 : _raise_ms_exception();
39951 0 : msResetErrorList();
39952 0 : return NULL;
39953 : }
39954 :
39955 : }
39956 : }
39957 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, 0 | 0 );
39958 1 : return resultobj;
39959 0 : fail:
39960 : return NULL;
39961 : }
39962 :
39963 :
39964 1 : SWIGINTERN PyObject *_wrap_lineObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39965 : PyObject *resultobj = 0;
39966 : lineObj *arg1 = (lineObj *) 0 ;
39967 : pointObj *arg2 = (pointObj *) 0 ;
39968 1 : void *argp1 = 0 ;
39969 : int res1 = 0 ;
39970 1 : void *argp2 = 0 ;
39971 : int res2 = 0 ;
39972 1 : PyObject * obj0 = 0 ;
39973 1 : PyObject * obj1 = 0 ;
39974 : int result;
39975 :
39976 1 : if (!PyArg_ParseTuple(args,(char *)"OO:lineObj_add",&obj0,&obj1)) SWIG_fail;
39977 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 | 0 );
39978 1 : if (!SWIG_IsOK(res1)) {
39979 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_add" "', argument " "1"" of type '" "lineObj *""'");
39980 : }
39981 1 : arg1 = (lineObj *)(argp1);
39982 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
39983 1 : if (!SWIG_IsOK(res2)) {
39984 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "lineObj_add" "', argument " "2"" of type '" "pointObj *""'");
39985 : }
39986 1 : arg2 = (pointObj *)(argp2);
39987 : {
39988 1 : result = (int)lineObj_add(arg1,arg2); {
39989 1 : errorObj *ms_error = msGetErrorObj();
39990 :
39991 1 : switch(ms_error->code) {
39992 : case MS_NOERR:
39993 : break;
39994 0 : case MS_NOTFOUND:
39995 0 : msResetErrorList();
39996 0 : break;
39997 : case -1:
39998 : break;
39999 0 : case MS_IOERR:
40000 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40001 0 : _raise_ms_exception();
40002 0 : msResetErrorList();
40003 0 : return NULL;
40004 : }
40005 : default:
40006 0 : _raise_ms_exception();
40007 0 : msResetErrorList();
40008 0 : return NULL;
40009 : }
40010 :
40011 : }
40012 : }
40013 : resultobj = SWIG_From_int((int)(result));
40014 1 : return resultobj;
40015 0 : fail:
40016 : return NULL;
40017 : }
40018 :
40019 :
40020 0 : SWIGINTERN PyObject *_wrap_lineObj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40021 : PyObject *resultobj = 0;
40022 : lineObj *arg1 = (lineObj *) 0 ;
40023 : int arg2 ;
40024 : pointObj *arg3 = (pointObj *) 0 ;
40025 0 : void *argp1 = 0 ;
40026 : int res1 = 0 ;
40027 : int val2 ;
40028 : int ecode2 = 0 ;
40029 0 : void *argp3 = 0 ;
40030 : int res3 = 0 ;
40031 0 : PyObject * obj0 = 0 ;
40032 0 : PyObject * obj1 = 0 ;
40033 0 : PyObject * obj2 = 0 ;
40034 : int result;
40035 :
40036 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:lineObj_set",&obj0,&obj1,&obj2)) SWIG_fail;
40037 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_lineObj, 0 | 0 );
40038 0 : if (!SWIG_IsOK(res1)) {
40039 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "lineObj_set" "', argument " "1"" of type '" "lineObj *""'");
40040 : }
40041 0 : arg1 = (lineObj *)(argp1);
40042 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40043 0 : if (!SWIG_IsOK(ecode2)) {
40044 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "lineObj_set" "', argument " "2"" of type '" "int""'");
40045 : }
40046 : arg2 = (int)(val2);
40047 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
40048 0 : if (!SWIG_IsOK(res3)) {
40049 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "lineObj_set" "', argument " "3"" of type '" "pointObj *""'");
40050 : }
40051 0 : arg3 = (pointObj *)(argp3);
40052 : {
40053 : result = (int)lineObj_set(arg1,arg2,arg3); {
40054 0 : errorObj *ms_error = msGetErrorObj();
40055 :
40056 0 : switch(ms_error->code) {
40057 : case MS_NOERR:
40058 : break;
40059 0 : case MS_NOTFOUND:
40060 0 : msResetErrorList();
40061 0 : break;
40062 : case -1:
40063 : break;
40064 0 : case MS_IOERR:
40065 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40066 0 : _raise_ms_exception();
40067 0 : msResetErrorList();
40068 0 : return NULL;
40069 : }
40070 : default:
40071 0 : _raise_ms_exception();
40072 0 : msResetErrorList();
40073 0 : return NULL;
40074 : }
40075 :
40076 : }
40077 : }
40078 : resultobj = SWIG_From_int((int)(result));
40079 0 : return resultobj;
40080 0 : fail:
40081 : return NULL;
40082 : }
40083 :
40084 :
40085 1 : SWIGINTERN PyObject *lineObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40086 : PyObject *obj;
40087 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
40088 1 : SWIG_TypeNewClientData(SWIGTYPE_p_lineObj, SWIG_NewClientData(obj));
40089 1 : return SWIG_Py_Void();
40090 : }
40091 :
40092 1 : SWIGINTERN PyObject *_wrap_shapeObj_numlines_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40093 : PyObject *resultobj = 0;
40094 : shapeObj *arg1 = (shapeObj *) 0 ;
40095 1 : void *argp1 = 0 ;
40096 : int res1 = 0 ;
40097 1 : PyObject * obj0 = 0 ;
40098 : int result;
40099 :
40100 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_numlines_get",&obj0)) SWIG_fail;
40101 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40102 1 : if (!SWIG_IsOK(res1)) {
40103 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_numlines_get" "', argument " "1"" of type '" "shapeObj *""'");
40104 : }
40105 1 : arg1 = (shapeObj *)(argp1);
40106 1 : result = (int) ((arg1)->numlines);
40107 : resultobj = SWIG_From_int((int)(result));
40108 1 : return resultobj;
40109 0 : fail:
40110 : return NULL;
40111 : }
40112 :
40113 :
40114 1 : SWIGINTERN PyObject *_wrap_shapeObj_numvalues_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40115 : PyObject *resultobj = 0;
40116 : shapeObj *arg1 = (shapeObj *) 0 ;
40117 1 : void *argp1 = 0 ;
40118 : int res1 = 0 ;
40119 1 : PyObject * obj0 = 0 ;
40120 : int result;
40121 :
40122 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_numvalues_get",&obj0)) SWIG_fail;
40123 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40124 1 : if (!SWIG_IsOK(res1)) {
40125 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_numvalues_get" "', argument " "1"" of type '" "shapeObj *""'");
40126 : }
40127 1 : arg1 = (shapeObj *)(argp1);
40128 1 : result = (int) ((arg1)->numvalues);
40129 : resultobj = SWIG_From_int((int)(result));
40130 1 : return resultobj;
40131 0 : fail:
40132 : return NULL;
40133 : }
40134 :
40135 :
40136 0 : SWIGINTERN PyObject *_wrap_shapeObj_bounds_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40137 : PyObject *resultobj = 0;
40138 : shapeObj *arg1 = (shapeObj *) 0 ;
40139 : rectObj *arg2 = (rectObj *) 0 ;
40140 0 : void *argp1 = 0 ;
40141 : int res1 = 0 ;
40142 0 : void *argp2 = 0 ;
40143 : int res2 = 0 ;
40144 0 : PyObject * obj0 = 0 ;
40145 0 : PyObject * obj1 = 0 ;
40146 :
40147 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_bounds_set",&obj0,&obj1)) SWIG_fail;
40148 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40149 0 : if (!SWIG_IsOK(res1)) {
40150 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_bounds_set" "', argument " "1"" of type '" "shapeObj *""'");
40151 : }
40152 0 : arg1 = (shapeObj *)(argp1);
40153 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_rectObj, 0 | 0 );
40154 0 : if (!SWIG_IsOK(res2)) {
40155 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_bounds_set" "', argument " "2"" of type '" "rectObj *""'");
40156 : }
40157 0 : arg2 = (rectObj *)(argp2);
40158 0 : if (arg1) (arg1)->bounds = *arg2;
40159 : resultobj = SWIG_Py_Void();
40160 0 : return resultobj;
40161 0 : fail:
40162 : return NULL;
40163 : }
40164 :
40165 :
40166 1 : SWIGINTERN PyObject *_wrap_shapeObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40167 : PyObject *resultobj = 0;
40168 : shapeObj *arg1 = (shapeObj *) 0 ;
40169 1 : void *argp1 = 0 ;
40170 : int res1 = 0 ;
40171 1 : PyObject * obj0 = 0 ;
40172 : rectObj *result = 0 ;
40173 :
40174 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_bounds_get",&obj0)) SWIG_fail;
40175 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40176 1 : if (!SWIG_IsOK(res1)) {
40177 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_bounds_get" "', argument " "1"" of type '" "shapeObj *""'");
40178 : }
40179 1 : arg1 = (shapeObj *)(argp1);
40180 1 : result = (rectObj *)& ((arg1)->bounds);
40181 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
40182 1 : return resultobj;
40183 0 : fail:
40184 : return NULL;
40185 : }
40186 :
40187 :
40188 0 : SWIGINTERN PyObject *_wrap_shapeObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40189 : PyObject *resultobj = 0;
40190 : shapeObj *arg1 = (shapeObj *) 0 ;
40191 : int arg2 ;
40192 0 : void *argp1 = 0 ;
40193 : int res1 = 0 ;
40194 : int val2 ;
40195 : int ecode2 = 0 ;
40196 0 : PyObject * obj0 = 0 ;
40197 0 : PyObject * obj1 = 0 ;
40198 :
40199 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_type_set",&obj0,&obj1)) SWIG_fail;
40200 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40201 0 : if (!SWIG_IsOK(res1)) {
40202 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_type_set" "', argument " "1"" of type '" "shapeObj *""'");
40203 : }
40204 0 : arg1 = (shapeObj *)(argp1);
40205 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40206 0 : if (!SWIG_IsOK(ecode2)) {
40207 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_type_set" "', argument " "2"" of type '" "int""'");
40208 : }
40209 : arg2 = (int)(val2);
40210 0 : if (arg1) (arg1)->type = arg2;
40211 : resultobj = SWIG_Py_Void();
40212 0 : return resultobj;
40213 0 : fail:
40214 : return NULL;
40215 : }
40216 :
40217 :
40218 1 : SWIGINTERN PyObject *_wrap_shapeObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40219 : PyObject *resultobj = 0;
40220 : shapeObj *arg1 = (shapeObj *) 0 ;
40221 1 : void *argp1 = 0 ;
40222 : int res1 = 0 ;
40223 1 : PyObject * obj0 = 0 ;
40224 : int result;
40225 :
40226 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_type_get",&obj0)) SWIG_fail;
40227 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40228 1 : if (!SWIG_IsOK(res1)) {
40229 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_type_get" "', argument " "1"" of type '" "shapeObj *""'");
40230 : }
40231 1 : arg1 = (shapeObj *)(argp1);
40232 1 : result = (int) ((arg1)->type);
40233 : resultobj = SWIG_From_int((int)(result));
40234 1 : return resultobj;
40235 0 : fail:
40236 : return NULL;
40237 : }
40238 :
40239 :
40240 0 : SWIGINTERN PyObject *_wrap_shapeObj_index_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40241 : PyObject *resultobj = 0;
40242 : shapeObj *arg1 = (shapeObj *) 0 ;
40243 : long arg2 ;
40244 0 : void *argp1 = 0 ;
40245 : int res1 = 0 ;
40246 : long val2 ;
40247 : int ecode2 = 0 ;
40248 0 : PyObject * obj0 = 0 ;
40249 0 : PyObject * obj1 = 0 ;
40250 :
40251 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_index_set",&obj0,&obj1)) SWIG_fail;
40252 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40253 0 : if (!SWIG_IsOK(res1)) {
40254 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_index_set" "', argument " "1"" of type '" "shapeObj *""'");
40255 : }
40256 0 : arg1 = (shapeObj *)(argp1);
40257 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
40258 0 : if (!SWIG_IsOK(ecode2)) {
40259 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_index_set" "', argument " "2"" of type '" "long""'");
40260 : }
40261 0 : arg2 = (long)(val2);
40262 0 : if (arg1) (arg1)->index = arg2;
40263 : resultobj = SWIG_Py_Void();
40264 0 : return resultobj;
40265 0 : fail:
40266 : return NULL;
40267 : }
40268 :
40269 :
40270 0 : SWIGINTERN PyObject *_wrap_shapeObj_index_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40271 : PyObject *resultobj = 0;
40272 : shapeObj *arg1 = (shapeObj *) 0 ;
40273 0 : void *argp1 = 0 ;
40274 : int res1 = 0 ;
40275 0 : PyObject * obj0 = 0 ;
40276 : long result;
40277 :
40278 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_index_get",&obj0)) SWIG_fail;
40279 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40280 0 : if (!SWIG_IsOK(res1)) {
40281 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_index_get" "', argument " "1"" of type '" "shapeObj *""'");
40282 : }
40283 0 : arg1 = (shapeObj *)(argp1);
40284 0 : result = (long) ((arg1)->index);
40285 0 : resultobj = SWIG_From_long((long)(result));
40286 0 : return resultobj;
40287 0 : fail:
40288 : return NULL;
40289 : }
40290 :
40291 :
40292 0 : SWIGINTERN PyObject *_wrap_shapeObj_tileindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40293 : PyObject *resultobj = 0;
40294 : shapeObj *arg1 = (shapeObj *) 0 ;
40295 : int arg2 ;
40296 0 : void *argp1 = 0 ;
40297 : int res1 = 0 ;
40298 : int val2 ;
40299 : int ecode2 = 0 ;
40300 0 : PyObject * obj0 = 0 ;
40301 0 : PyObject * obj1 = 0 ;
40302 :
40303 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_tileindex_set",&obj0,&obj1)) SWIG_fail;
40304 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40305 0 : if (!SWIG_IsOK(res1)) {
40306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_tileindex_set" "', argument " "1"" of type '" "shapeObj *""'");
40307 : }
40308 0 : arg1 = (shapeObj *)(argp1);
40309 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40310 0 : if (!SWIG_IsOK(ecode2)) {
40311 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_tileindex_set" "', argument " "2"" of type '" "int""'");
40312 : }
40313 : arg2 = (int)(val2);
40314 0 : if (arg1) (arg1)->tileindex = arg2;
40315 : resultobj = SWIG_Py_Void();
40316 0 : return resultobj;
40317 0 : fail:
40318 : return NULL;
40319 : }
40320 :
40321 :
40322 0 : SWIGINTERN PyObject *_wrap_shapeObj_tileindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40323 : PyObject *resultobj = 0;
40324 : shapeObj *arg1 = (shapeObj *) 0 ;
40325 0 : void *argp1 = 0 ;
40326 : int res1 = 0 ;
40327 0 : PyObject * obj0 = 0 ;
40328 : int result;
40329 :
40330 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_tileindex_get",&obj0)) SWIG_fail;
40331 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40332 0 : if (!SWIG_IsOK(res1)) {
40333 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_tileindex_get" "', argument " "1"" of type '" "shapeObj *""'");
40334 : }
40335 0 : arg1 = (shapeObj *)(argp1);
40336 0 : result = (int) ((arg1)->tileindex);
40337 : resultobj = SWIG_From_int((int)(result));
40338 0 : return resultobj;
40339 0 : fail:
40340 : return NULL;
40341 : }
40342 :
40343 :
40344 1 : SWIGINTERN PyObject *_wrap_shapeObj_classindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40345 : PyObject *resultobj = 0;
40346 : shapeObj *arg1 = (shapeObj *) 0 ;
40347 : int arg2 ;
40348 1 : void *argp1 = 0 ;
40349 : int res1 = 0 ;
40350 : int val2 ;
40351 : int ecode2 = 0 ;
40352 1 : PyObject * obj0 = 0 ;
40353 1 : PyObject * obj1 = 0 ;
40354 :
40355 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_classindex_set",&obj0,&obj1)) SWIG_fail;
40356 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40357 1 : if (!SWIG_IsOK(res1)) {
40358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_classindex_set" "', argument " "1"" of type '" "shapeObj *""'");
40359 : }
40360 1 : arg1 = (shapeObj *)(argp1);
40361 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40362 1 : if (!SWIG_IsOK(ecode2)) {
40363 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_classindex_set" "', argument " "2"" of type '" "int""'");
40364 : }
40365 : arg2 = (int)(val2);
40366 1 : if (arg1) (arg1)->classindex = arg2;
40367 : resultobj = SWIG_Py_Void();
40368 1 : return resultobj;
40369 0 : fail:
40370 : return NULL;
40371 : }
40372 :
40373 :
40374 0 : SWIGINTERN PyObject *_wrap_shapeObj_classindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40375 : PyObject *resultobj = 0;
40376 : shapeObj *arg1 = (shapeObj *) 0 ;
40377 0 : void *argp1 = 0 ;
40378 : int res1 = 0 ;
40379 0 : PyObject * obj0 = 0 ;
40380 : int result;
40381 :
40382 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_classindex_get",&obj0)) SWIG_fail;
40383 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40384 0 : if (!SWIG_IsOK(res1)) {
40385 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_classindex_get" "', argument " "1"" of type '" "shapeObj *""'");
40386 : }
40387 0 : arg1 = (shapeObj *)(argp1);
40388 0 : result = (int) ((arg1)->classindex);
40389 : resultobj = SWIG_From_int((int)(result));
40390 0 : return resultobj;
40391 0 : fail:
40392 : return NULL;
40393 : }
40394 :
40395 :
40396 1 : SWIGINTERN PyObject *_wrap_shapeObj_text_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40397 : PyObject *resultobj = 0;
40398 : shapeObj *arg1 = (shapeObj *) 0 ;
40399 : char *arg2 = (char *) 0 ;
40400 1 : void *argp1 = 0 ;
40401 : int res1 = 0 ;
40402 : int res2 ;
40403 1 : char *buf2 = 0 ;
40404 1 : int alloc2 = 0 ;
40405 1 : PyObject * obj0 = 0 ;
40406 1 : PyObject * obj1 = 0 ;
40407 :
40408 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_text_set",&obj0,&obj1)) SWIG_fail;
40409 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40410 1 : if (!SWIG_IsOK(res1)) {
40411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_text_set" "', argument " "1"" of type '" "shapeObj *""'");
40412 : }
40413 1 : arg1 = (shapeObj *)(argp1);
40414 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
40415 1 : if (!SWIG_IsOK(res2)) {
40416 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_text_set" "', argument " "2"" of type '" "char *""'");
40417 : }
40418 1 : arg2 = (char *)(buf2);
40419 : {
40420 1 : if (arg1->text) free((char*)arg1->text);
40421 1 : if (arg2) {
40422 1 : arg1->text = (char *) malloc(strlen(arg2)+1);
40423 : strcpy((char*)arg1->text,arg2);
40424 : } else {
40425 0 : arg1->text = 0;
40426 : }
40427 : }
40428 : resultobj = SWIG_Py_Void();
40429 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40430 : return resultobj;
40431 0 : fail:
40432 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
40433 : return NULL;
40434 : }
40435 :
40436 :
40437 0 : SWIGINTERN PyObject *_wrap_shapeObj_text_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40438 : PyObject *resultobj = 0;
40439 : shapeObj *arg1 = (shapeObj *) 0 ;
40440 0 : void *argp1 = 0 ;
40441 : int res1 = 0 ;
40442 0 : PyObject * obj0 = 0 ;
40443 : char *result = 0 ;
40444 :
40445 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_text_get",&obj0)) SWIG_fail;
40446 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40447 0 : if (!SWIG_IsOK(res1)) {
40448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_text_get" "', argument " "1"" of type '" "shapeObj *""'");
40449 : }
40450 0 : arg1 = (shapeObj *)(argp1);
40451 0 : result = (char *) ((arg1)->text);
40452 0 : resultobj = SWIG_FromCharPtr((const char *)result);
40453 0 : return resultobj;
40454 0 : fail:
40455 : return NULL;
40456 : }
40457 :
40458 :
40459 0 : SWIGINTERN PyObject *_wrap_shapeObj_scratch_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40460 : PyObject *resultobj = 0;
40461 : shapeObj *arg1 = (shapeObj *) 0 ;
40462 : int arg2 ;
40463 0 : void *argp1 = 0 ;
40464 : int res1 = 0 ;
40465 : int val2 ;
40466 : int ecode2 = 0 ;
40467 0 : PyObject * obj0 = 0 ;
40468 0 : PyObject * obj1 = 0 ;
40469 :
40470 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_scratch_set",&obj0,&obj1)) SWIG_fail;
40471 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40472 0 : if (!SWIG_IsOK(res1)) {
40473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_scratch_set" "', argument " "1"" of type '" "shapeObj *""'");
40474 : }
40475 0 : arg1 = (shapeObj *)(argp1);
40476 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40477 0 : if (!SWIG_IsOK(ecode2)) {
40478 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_scratch_set" "', argument " "2"" of type '" "int""'");
40479 : }
40480 : arg2 = (int)(val2);
40481 0 : if (arg1) (arg1)->scratch = arg2;
40482 : resultobj = SWIG_Py_Void();
40483 0 : return resultobj;
40484 0 : fail:
40485 : return NULL;
40486 : }
40487 :
40488 :
40489 0 : SWIGINTERN PyObject *_wrap_shapeObj_scratch_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40490 : PyObject *resultobj = 0;
40491 : shapeObj *arg1 = (shapeObj *) 0 ;
40492 0 : void *argp1 = 0 ;
40493 : int res1 = 0 ;
40494 0 : PyObject * obj0 = 0 ;
40495 : int result;
40496 :
40497 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_scratch_get",&obj0)) SWIG_fail;
40498 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40499 0 : if (!SWIG_IsOK(res1)) {
40500 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_scratch_get" "', argument " "1"" of type '" "shapeObj *""'");
40501 : }
40502 0 : arg1 = (shapeObj *)(argp1);
40503 0 : result = (int) ((arg1)->scratch);
40504 : resultobj = SWIG_From_int((int)(result));
40505 0 : return resultobj;
40506 0 : fail:
40507 : return NULL;
40508 : }
40509 :
40510 :
40511 0 : SWIGINTERN PyObject *_wrap_shapeObj_resultindex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40512 : PyObject *resultobj = 0;
40513 : shapeObj *arg1 = (shapeObj *) 0 ;
40514 : int arg2 ;
40515 0 : void *argp1 = 0 ;
40516 : int res1 = 0 ;
40517 : int val2 ;
40518 : int ecode2 = 0 ;
40519 0 : PyObject * obj0 = 0 ;
40520 0 : PyObject * obj1 = 0 ;
40521 :
40522 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_resultindex_set",&obj0,&obj1)) SWIG_fail;
40523 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40524 0 : if (!SWIG_IsOK(res1)) {
40525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_resultindex_set" "', argument " "1"" of type '" "shapeObj *""'");
40526 : }
40527 0 : arg1 = (shapeObj *)(argp1);
40528 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40529 0 : if (!SWIG_IsOK(ecode2)) {
40530 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_resultindex_set" "', argument " "2"" of type '" "int""'");
40531 : }
40532 : arg2 = (int)(val2);
40533 0 : if (arg1) (arg1)->resultindex = arg2;
40534 : resultobj = SWIG_Py_Void();
40535 0 : return resultobj;
40536 0 : fail:
40537 : return NULL;
40538 : }
40539 :
40540 :
40541 0 : SWIGINTERN PyObject *_wrap_shapeObj_resultindex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40542 : PyObject *resultobj = 0;
40543 : shapeObj *arg1 = (shapeObj *) 0 ;
40544 0 : void *argp1 = 0 ;
40545 : int res1 = 0 ;
40546 0 : PyObject * obj0 = 0 ;
40547 : int result;
40548 :
40549 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_resultindex_get",&obj0)) SWIG_fail;
40550 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40551 0 : if (!SWIG_IsOK(res1)) {
40552 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_resultindex_get" "', argument " "1"" of type '" "shapeObj *""'");
40553 : }
40554 0 : arg1 = (shapeObj *)(argp1);
40555 0 : result = (int) ((arg1)->resultindex);
40556 : resultobj = SWIG_From_int((int)(result));
40557 0 : return resultobj;
40558 0 : fail:
40559 : return NULL;
40560 : }
40561 :
40562 :
40563 1 : SWIGINTERN PyObject *_wrap_new_shapeObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40564 : PyObject *resultobj = 0;
40565 : int arg1 = (int) MS_SHAPE_NULL ;
40566 : int val1 ;
40567 : int ecode1 = 0 ;
40568 1 : PyObject * obj0 = 0 ;
40569 : shapeObj *result = 0 ;
40570 :
40571 1 : if (!PyArg_ParseTuple(args,(char *)"|O:new_shapeObj",&obj0)) SWIG_fail;
40572 1 : if (obj0) {
40573 : ecode1 = SWIG_AsVal_int(obj0, &val1);
40574 1 : if (!SWIG_IsOK(ecode1)) {
40575 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_shapeObj" "', argument " "1"" of type '" "int""'");
40576 : }
40577 : arg1 = (int)(val1);
40578 : }
40579 : {
40580 1 : result = (shapeObj *)new_shapeObj(arg1); {
40581 1 : errorObj *ms_error = msGetErrorObj();
40582 :
40583 1 : switch(ms_error->code) {
40584 : case MS_NOERR:
40585 : break;
40586 0 : case MS_NOTFOUND:
40587 0 : msResetErrorList();
40588 0 : break;
40589 : case -1:
40590 : break;
40591 0 : case MS_IOERR:
40592 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40593 0 : _raise_ms_exception();
40594 0 : msResetErrorList();
40595 0 : return NULL;
40596 : }
40597 : default:
40598 0 : _raise_ms_exception();
40599 0 : msResetErrorList();
40600 0 : return NULL;
40601 : }
40602 :
40603 : }
40604 : }
40605 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_NEW | 0 );
40606 1 : return resultobj;
40607 0 : fail:
40608 : return NULL;
40609 : }
40610 :
40611 :
40612 1 : SWIGINTERN PyObject *_wrap_delete_shapeObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40613 : PyObject *resultobj = 0;
40614 : shapeObj *arg1 = (shapeObj *) 0 ;
40615 1 : void *argp1 = 0 ;
40616 : int res1 = 0 ;
40617 1 : PyObject * obj0 = 0 ;
40618 :
40619 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_shapeObj",&obj0)) SWIG_fail;
40620 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, SWIG_POINTER_DISOWN | 0 );
40621 1 : if (!SWIG_IsOK(res1)) {
40622 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shapeObj" "', argument " "1"" of type '" "shapeObj *""'");
40623 : }
40624 1 : arg1 = (shapeObj *)(argp1);
40625 : {
40626 : delete_shapeObj(arg1); {
40627 1 : errorObj *ms_error = msGetErrorObj();
40628 :
40629 1 : switch(ms_error->code) {
40630 : case MS_NOERR:
40631 : break;
40632 0 : case MS_NOTFOUND:
40633 0 : msResetErrorList();
40634 0 : break;
40635 : case -1:
40636 : break;
40637 0 : case MS_IOERR:
40638 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40639 0 : _raise_ms_exception();
40640 0 : msResetErrorList();
40641 0 : return NULL;
40642 : }
40643 : default:
40644 0 : _raise_ms_exception();
40645 0 : msResetErrorList();
40646 0 : return NULL;
40647 : }
40648 :
40649 : }
40650 : }
40651 : resultobj = SWIG_Py_Void();
40652 1 : return resultobj;
40653 0 : fail:
40654 : return NULL;
40655 : }
40656 :
40657 :
40658 1 : SWIGINTERN PyObject *_wrap_shapeObj_fromWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40659 : PyObject *resultobj = 0;
40660 : char *arg1 = (char *) 0 ;
40661 : int res1 ;
40662 1 : char *buf1 = 0 ;
40663 1 : int alloc1 = 0 ;
40664 1 : PyObject * obj0 = 0 ;
40665 : shapeObj *result = 0 ;
40666 :
40667 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_fromWKT",&obj0)) SWIG_fail;
40668 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
40669 1 : if (!SWIG_IsOK(res1)) {
40670 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_fromWKT" "', argument " "1"" of type '" "char *""'");
40671 : }
40672 1 : arg1 = (char *)(buf1);
40673 : {
40674 : result = (shapeObj *)shapeObj_fromWKT(arg1); {
40675 1 : errorObj *ms_error = msGetErrorObj();
40676 :
40677 1 : switch(ms_error->code) {
40678 : case MS_NOERR:
40679 : break;
40680 0 : case MS_NOTFOUND:
40681 0 : msResetErrorList();
40682 0 : break;
40683 : case -1:
40684 : break;
40685 0 : case MS_IOERR:
40686 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40687 0 : _raise_ms_exception();
40688 0 : msResetErrorList();
40689 0 : return NULL;
40690 : }
40691 : default:
40692 0 : _raise_ms_exception();
40693 0 : msResetErrorList();
40694 0 : return NULL;
40695 : }
40696 :
40697 : }
40698 : }
40699 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
40700 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
40701 : return resultobj;
40702 0 : fail:
40703 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
40704 : return NULL;
40705 : }
40706 :
40707 :
40708 1 : SWIGINTERN PyObject *_wrap_shapeObj_project(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40709 : PyObject *resultobj = 0;
40710 : shapeObj *arg1 = (shapeObj *) 0 ;
40711 : projectionObj *arg2 = (projectionObj *) 0 ;
40712 : projectionObj *arg3 = (projectionObj *) 0 ;
40713 1 : void *argp1 = 0 ;
40714 : int res1 = 0 ;
40715 1 : void *argp2 = 0 ;
40716 : int res2 = 0 ;
40717 1 : void *argp3 = 0 ;
40718 : int res3 = 0 ;
40719 1 : PyObject * obj0 = 0 ;
40720 1 : PyObject * obj1 = 0 ;
40721 1 : PyObject * obj2 = 0 ;
40722 : int result;
40723 :
40724 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:shapeObj_project",&obj0,&obj1,&obj2)) SWIG_fail;
40725 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40726 1 : if (!SWIG_IsOK(res1)) {
40727 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_project" "', argument " "1"" of type '" "shapeObj *""'");
40728 : }
40729 1 : arg1 = (shapeObj *)(argp1);
40730 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_projectionObj, 0 | 0 );
40731 1 : if (!SWIG_IsOK(res2)) {
40732 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_project" "', argument " "2"" of type '" "projectionObj *""'");
40733 : }
40734 1 : arg2 = (projectionObj *)(argp2);
40735 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_projectionObj, 0 | 0 );
40736 1 : if (!SWIG_IsOK(res3)) {
40737 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_project" "', argument " "3"" of type '" "projectionObj *""'");
40738 : }
40739 1 : arg3 = (projectionObj *)(argp3);
40740 : {
40741 : result = (int)shapeObj_project(arg1,arg2,arg3); {
40742 1 : errorObj *ms_error = msGetErrorObj();
40743 :
40744 1 : switch(ms_error->code) {
40745 : case MS_NOERR:
40746 : break;
40747 0 : case MS_NOTFOUND:
40748 0 : msResetErrorList();
40749 0 : break;
40750 : case -1:
40751 : break;
40752 0 : case MS_IOERR:
40753 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40754 0 : _raise_ms_exception();
40755 0 : msResetErrorList();
40756 0 : return NULL;
40757 : }
40758 : default:
40759 0 : _raise_ms_exception();
40760 0 : msResetErrorList();
40761 0 : return NULL;
40762 : }
40763 :
40764 : }
40765 : }
40766 : resultobj = SWIG_From_int((int)(result));
40767 1 : return resultobj;
40768 0 : fail:
40769 : return NULL;
40770 : }
40771 :
40772 :
40773 1 : SWIGINTERN PyObject *_wrap_shapeObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40774 : PyObject *resultobj = 0;
40775 : shapeObj *arg1 = (shapeObj *) 0 ;
40776 : int arg2 ;
40777 1 : void *argp1 = 0 ;
40778 : int res1 = 0 ;
40779 : int val2 ;
40780 : int ecode2 = 0 ;
40781 1 : PyObject * obj0 = 0 ;
40782 1 : PyObject * obj1 = 0 ;
40783 : lineObj *result = 0 ;
40784 :
40785 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_get",&obj0,&obj1)) SWIG_fail;
40786 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40787 1 : if (!SWIG_IsOK(res1)) {
40788 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_get" "', argument " "1"" of type '" "shapeObj *""'");
40789 : }
40790 1 : arg1 = (shapeObj *)(argp1);
40791 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
40792 1 : if (!SWIG_IsOK(ecode2)) {
40793 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_get" "', argument " "2"" of type '" "int""'");
40794 : }
40795 : arg2 = (int)(val2);
40796 : {
40797 : result = (lineObj *)shapeObj_get(arg1,arg2); {
40798 1 : errorObj *ms_error = msGetErrorObj();
40799 :
40800 1 : switch(ms_error->code) {
40801 : case MS_NOERR:
40802 : break;
40803 0 : case MS_NOTFOUND:
40804 0 : msResetErrorList();
40805 0 : break;
40806 : case -1:
40807 : break;
40808 0 : case MS_IOERR:
40809 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40810 0 : _raise_ms_exception();
40811 0 : msResetErrorList();
40812 0 : return NULL;
40813 : }
40814 : default:
40815 0 : _raise_ms_exception();
40816 0 : msResetErrorList();
40817 0 : return NULL;
40818 : }
40819 :
40820 : }
40821 : }
40822 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, 0 | 0 );
40823 1 : return resultobj;
40824 0 : fail:
40825 : return NULL;
40826 : }
40827 :
40828 :
40829 1 : SWIGINTERN PyObject *_wrap_shapeObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40830 : PyObject *resultobj = 0;
40831 : shapeObj *arg1 = (shapeObj *) 0 ;
40832 : lineObj *arg2 = (lineObj *) 0 ;
40833 1 : void *argp1 = 0 ;
40834 : int res1 = 0 ;
40835 1 : void *argp2 = 0 ;
40836 : int res2 = 0 ;
40837 1 : PyObject * obj0 = 0 ;
40838 1 : PyObject * obj1 = 0 ;
40839 : int result;
40840 :
40841 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_add",&obj0,&obj1)) SWIG_fail;
40842 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40843 1 : if (!SWIG_IsOK(res1)) {
40844 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_add" "', argument " "1"" of type '" "shapeObj *""'");
40845 : }
40846 1 : arg1 = (shapeObj *)(argp1);
40847 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_lineObj, 0 | 0 );
40848 1 : if (!SWIG_IsOK(res2)) {
40849 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_add" "', argument " "2"" of type '" "lineObj *""'");
40850 : }
40851 1 : arg2 = (lineObj *)(argp2);
40852 : {
40853 : result = (int)shapeObj_add(arg1,arg2); {
40854 1 : errorObj *ms_error = msGetErrorObj();
40855 :
40856 1 : switch(ms_error->code) {
40857 : case MS_NOERR:
40858 : break;
40859 0 : case MS_NOTFOUND:
40860 0 : msResetErrorList();
40861 0 : break;
40862 : case -1:
40863 : break;
40864 0 : case MS_IOERR:
40865 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40866 0 : _raise_ms_exception();
40867 0 : msResetErrorList();
40868 0 : return NULL;
40869 : }
40870 : default:
40871 0 : _raise_ms_exception();
40872 0 : msResetErrorList();
40873 0 : return NULL;
40874 : }
40875 :
40876 : }
40877 : }
40878 : resultobj = SWIG_From_int((int)(result));
40879 1 : return resultobj;
40880 0 : fail:
40881 : return NULL;
40882 : }
40883 :
40884 :
40885 0 : SWIGINTERN PyObject *_wrap_shapeObj_draw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40886 : PyObject *resultobj = 0;
40887 : shapeObj *arg1 = (shapeObj *) 0 ;
40888 : mapObj *arg2 = (mapObj *) 0 ;
40889 : layerObj *arg3 = (layerObj *) 0 ;
40890 : imageObj *arg4 = (imageObj *) 0 ;
40891 0 : void *argp1 = 0 ;
40892 : int res1 = 0 ;
40893 0 : void *argp2 = 0 ;
40894 : int res2 = 0 ;
40895 0 : void *argp3 = 0 ;
40896 : int res3 = 0 ;
40897 0 : void *argp4 = 0 ;
40898 : int res4 = 0 ;
40899 0 : PyObject * obj0 = 0 ;
40900 0 : PyObject * obj1 = 0 ;
40901 0 : PyObject * obj2 = 0 ;
40902 0 : PyObject * obj3 = 0 ;
40903 : int result;
40904 :
40905 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:shapeObj_draw",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40906 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40907 0 : if (!SWIG_IsOK(res1)) {
40908 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_draw" "', argument " "1"" of type '" "shapeObj *""'");
40909 : }
40910 0 : arg1 = (shapeObj *)(argp1);
40911 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
40912 0 : if (!SWIG_IsOK(res2)) {
40913 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_draw" "', argument " "2"" of type '" "mapObj *""'");
40914 : }
40915 0 : arg2 = (mapObj *)(argp2);
40916 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_layerObj, 0 | 0 );
40917 0 : if (!SWIG_IsOK(res3)) {
40918 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_draw" "', argument " "3"" of type '" "layerObj *""'");
40919 : }
40920 0 : arg3 = (layerObj *)(argp3);
40921 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_imageObj, 0 | 0 );
40922 0 : if (!SWIG_IsOK(res4)) {
40923 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "shapeObj_draw" "', argument " "4"" of type '" "imageObj *""'");
40924 : }
40925 0 : arg4 = (imageObj *)(argp4);
40926 : {
40927 : result = (int)shapeObj_draw(arg1,arg2,arg3,arg4); {
40928 0 : errorObj *ms_error = msGetErrorObj();
40929 :
40930 0 : switch(ms_error->code) {
40931 : case MS_NOERR:
40932 : break;
40933 0 : case MS_NOTFOUND:
40934 0 : msResetErrorList();
40935 0 : break;
40936 : case -1:
40937 : break;
40938 0 : case MS_IOERR:
40939 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40940 0 : _raise_ms_exception();
40941 0 : msResetErrorList();
40942 0 : return NULL;
40943 : }
40944 : default:
40945 0 : _raise_ms_exception();
40946 0 : msResetErrorList();
40947 0 : return NULL;
40948 : }
40949 :
40950 : }
40951 : }
40952 : resultobj = SWIG_From_int((int)(result));
40953 0 : return resultobj;
40954 0 : fail:
40955 : return NULL;
40956 : }
40957 :
40958 :
40959 1 : SWIGINTERN PyObject *_wrap_shapeObj_setBounds(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40960 : PyObject *resultobj = 0;
40961 : shapeObj *arg1 = (shapeObj *) 0 ;
40962 1 : void *argp1 = 0 ;
40963 : int res1 = 0 ;
40964 1 : PyObject * obj0 = 0 ;
40965 :
40966 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_setBounds",&obj0)) SWIG_fail;
40967 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
40968 1 : if (!SWIG_IsOK(res1)) {
40969 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_setBounds" "', argument " "1"" of type '" "shapeObj *""'");
40970 : }
40971 1 : arg1 = (shapeObj *)(argp1);
40972 : {
40973 : shapeObj_setBounds(arg1); {
40974 1 : errorObj *ms_error = msGetErrorObj();
40975 :
40976 1 : switch(ms_error->code) {
40977 : case MS_NOERR:
40978 : break;
40979 0 : case MS_NOTFOUND:
40980 0 : msResetErrorList();
40981 0 : break;
40982 : case -1:
40983 : break;
40984 0 : case MS_IOERR:
40985 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
40986 0 : _raise_ms_exception();
40987 0 : msResetErrorList();
40988 0 : return NULL;
40989 : }
40990 : default:
40991 0 : _raise_ms_exception();
40992 0 : msResetErrorList();
40993 0 : return NULL;
40994 : }
40995 :
40996 : }
40997 : }
40998 : resultobj = SWIG_Py_Void();
40999 1 : return resultobj;
41000 0 : fail:
41001 : return NULL;
41002 : }
41003 :
41004 :
41005 1 : SWIGINTERN PyObject *_wrap_shapeObj_clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41006 : PyObject *resultobj = 0;
41007 : shapeObj *arg1 = (shapeObj *) 0 ;
41008 1 : void *argp1 = 0 ;
41009 : int res1 = 0 ;
41010 1 : PyObject * obj0 = 0 ;
41011 : shapeObj *result = 0 ;
41012 :
41013 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_clone",&obj0)) SWIG_fail;
41014 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41015 1 : if (!SWIG_IsOK(res1)) {
41016 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_clone" "', argument " "1"" of type '" "shapeObj *""'");
41017 : }
41018 1 : arg1 = (shapeObj *)(argp1);
41019 : {
41020 1 : result = (shapeObj *)shapeObj_clone(arg1); {
41021 1 : errorObj *ms_error = msGetErrorObj();
41022 :
41023 1 : switch(ms_error->code) {
41024 : case MS_NOERR:
41025 : break;
41026 0 : case MS_NOTFOUND:
41027 0 : msResetErrorList();
41028 0 : break;
41029 : case -1:
41030 : break;
41031 0 : case MS_IOERR:
41032 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41033 0 : _raise_ms_exception();
41034 0 : msResetErrorList();
41035 0 : return NULL;
41036 : }
41037 : default:
41038 0 : _raise_ms_exception();
41039 0 : msResetErrorList();
41040 0 : return NULL;
41041 : }
41042 :
41043 : }
41044 : }
41045 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41046 1 : return resultobj;
41047 0 : fail:
41048 : return NULL;
41049 : }
41050 :
41051 :
41052 0 : SWIGINTERN PyObject *_wrap_shapeObj_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41053 : PyObject *resultobj = 0;
41054 : shapeObj *arg1 = (shapeObj *) 0 ;
41055 : shapeObj *arg2 = (shapeObj *) 0 ;
41056 0 : void *argp1 = 0 ;
41057 : int res1 = 0 ;
41058 0 : void *argp2 = 0 ;
41059 : int res2 = 0 ;
41060 0 : PyObject * obj0 = 0 ;
41061 0 : PyObject * obj1 = 0 ;
41062 : int result;
41063 :
41064 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_copy",&obj0,&obj1)) SWIG_fail;
41065 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41066 0 : if (!SWIG_IsOK(res1)) {
41067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_copy" "', argument " "1"" of type '" "shapeObj *""'");
41068 : }
41069 0 : arg1 = (shapeObj *)(argp1);
41070 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41071 0 : if (!SWIG_IsOK(res2)) {
41072 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_copy" "', argument " "2"" of type '" "shapeObj *""'");
41073 : }
41074 0 : arg2 = (shapeObj *)(argp2);
41075 : {
41076 : result = (int)shapeObj_copy(arg1,arg2); {
41077 0 : errorObj *ms_error = msGetErrorObj();
41078 :
41079 0 : switch(ms_error->code) {
41080 : case MS_NOERR:
41081 : break;
41082 0 : case MS_NOTFOUND:
41083 0 : msResetErrorList();
41084 0 : break;
41085 : case -1:
41086 : break;
41087 0 : case MS_IOERR:
41088 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41089 0 : _raise_ms_exception();
41090 0 : msResetErrorList();
41091 0 : return NULL;
41092 : }
41093 : default:
41094 0 : _raise_ms_exception();
41095 0 : msResetErrorList();
41096 0 : return NULL;
41097 : }
41098 :
41099 : }
41100 : }
41101 : resultobj = SWIG_From_int((int)(result));
41102 0 : return resultobj;
41103 0 : fail:
41104 : return NULL;
41105 : }
41106 :
41107 :
41108 1 : SWIGINTERN PyObject *_wrap_shapeObj_toWKT(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41109 : PyObject *resultobj = 0;
41110 : shapeObj *arg1 = (shapeObj *) 0 ;
41111 1 : void *argp1 = 0 ;
41112 : int res1 = 0 ;
41113 1 : PyObject * obj0 = 0 ;
41114 : char *result = 0 ;
41115 :
41116 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_toWKT",&obj0)) SWIG_fail;
41117 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41118 1 : if (!SWIG_IsOK(res1)) {
41119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_toWKT" "', argument " "1"" of type '" "shapeObj *""'");
41120 : }
41121 1 : arg1 = (shapeObj *)(argp1);
41122 : {
41123 : result = (char *)shapeObj_toWKT(arg1); {
41124 1 : errorObj *ms_error = msGetErrorObj();
41125 :
41126 1 : switch(ms_error->code) {
41127 : case MS_NOERR:
41128 : break;
41129 0 : case MS_NOTFOUND:
41130 0 : msResetErrorList();
41131 0 : break;
41132 : case -1:
41133 : break;
41134 0 : case MS_IOERR:
41135 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41136 0 : _raise_ms_exception();
41137 0 : msResetErrorList();
41138 0 : return NULL;
41139 : }
41140 : default:
41141 0 : _raise_ms_exception();
41142 0 : msResetErrorList();
41143 0 : return NULL;
41144 : }
41145 :
41146 : }
41147 : }
41148 1 : resultobj = SWIG_FromCharPtr((const char *)result);
41149 1 : free((char*)result);
41150 1 : return resultobj;
41151 0 : fail:
41152 : return NULL;
41153 : }
41154 :
41155 :
41156 0 : SWIGINTERN PyObject *_wrap_shapeObj_buffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41157 : PyObject *resultobj = 0;
41158 : shapeObj *arg1 = (shapeObj *) 0 ;
41159 : double arg2 ;
41160 0 : void *argp1 = 0 ;
41161 : int res1 = 0 ;
41162 : double val2 ;
41163 : int ecode2 = 0 ;
41164 0 : PyObject * obj0 = 0 ;
41165 0 : PyObject * obj1 = 0 ;
41166 : shapeObj *result = 0 ;
41167 :
41168 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_buffer",&obj0,&obj1)) SWIG_fail;
41169 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41170 0 : if (!SWIG_IsOK(res1)) {
41171 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_buffer" "', argument " "1"" of type '" "shapeObj *""'");
41172 : }
41173 0 : arg1 = (shapeObj *)(argp1);
41174 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
41175 0 : if (!SWIG_IsOK(ecode2)) {
41176 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_buffer" "', argument " "2"" of type '" "double""'");
41177 : }
41178 0 : arg2 = (double)(val2);
41179 : {
41180 : result = (shapeObj *)shapeObj_buffer(arg1,arg2); {
41181 0 : errorObj *ms_error = msGetErrorObj();
41182 :
41183 0 : switch(ms_error->code) {
41184 : case MS_NOERR:
41185 : break;
41186 0 : case MS_NOTFOUND:
41187 0 : msResetErrorList();
41188 0 : break;
41189 : case -1:
41190 : break;
41191 0 : case MS_IOERR:
41192 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41193 0 : _raise_ms_exception();
41194 0 : msResetErrorList();
41195 0 : return NULL;
41196 : }
41197 : default:
41198 0 : _raise_ms_exception();
41199 0 : msResetErrorList();
41200 0 : return NULL;
41201 : }
41202 :
41203 : }
41204 : }
41205 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41206 0 : return resultobj;
41207 0 : fail:
41208 : return NULL;
41209 : }
41210 :
41211 :
41212 0 : SWIGINTERN PyObject *_wrap_shapeObj_simplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41213 : PyObject *resultobj = 0;
41214 : shapeObj *arg1 = (shapeObj *) 0 ;
41215 : double arg2 ;
41216 0 : void *argp1 = 0 ;
41217 : int res1 = 0 ;
41218 : double val2 ;
41219 : int ecode2 = 0 ;
41220 0 : PyObject * obj0 = 0 ;
41221 0 : PyObject * obj1 = 0 ;
41222 : shapeObj *result = 0 ;
41223 :
41224 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_simplify",&obj0,&obj1)) SWIG_fail;
41225 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41226 0 : if (!SWIG_IsOK(res1)) {
41227 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_simplify" "', argument " "1"" of type '" "shapeObj *""'");
41228 : }
41229 0 : arg1 = (shapeObj *)(argp1);
41230 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
41231 0 : if (!SWIG_IsOK(ecode2)) {
41232 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_simplify" "', argument " "2"" of type '" "double""'");
41233 : }
41234 0 : arg2 = (double)(val2);
41235 : {
41236 : result = (shapeObj *)shapeObj_simplify(arg1,arg2); {
41237 0 : errorObj *ms_error = msGetErrorObj();
41238 :
41239 0 : switch(ms_error->code) {
41240 : case MS_NOERR:
41241 : break;
41242 0 : case MS_NOTFOUND:
41243 0 : msResetErrorList();
41244 0 : break;
41245 : case -1:
41246 : break;
41247 0 : case MS_IOERR:
41248 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41249 0 : _raise_ms_exception();
41250 0 : msResetErrorList();
41251 0 : return NULL;
41252 : }
41253 : default:
41254 0 : _raise_ms_exception();
41255 0 : msResetErrorList();
41256 0 : return NULL;
41257 : }
41258 :
41259 : }
41260 : }
41261 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41262 0 : return resultobj;
41263 0 : fail:
41264 : return NULL;
41265 : }
41266 :
41267 :
41268 0 : SWIGINTERN PyObject *_wrap_shapeObj_topologyPreservingSimplify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41269 : PyObject *resultobj = 0;
41270 : shapeObj *arg1 = (shapeObj *) 0 ;
41271 : double arg2 ;
41272 0 : void *argp1 = 0 ;
41273 : int res1 = 0 ;
41274 : double val2 ;
41275 : int ecode2 = 0 ;
41276 0 : PyObject * obj0 = 0 ;
41277 0 : PyObject * obj1 = 0 ;
41278 : shapeObj *result = 0 ;
41279 :
41280 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_topologyPreservingSimplify",&obj0,&obj1)) SWIG_fail;
41281 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41282 0 : if (!SWIG_IsOK(res1)) {
41283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_topologyPreservingSimplify" "', argument " "1"" of type '" "shapeObj *""'");
41284 : }
41285 0 : arg1 = (shapeObj *)(argp1);
41286 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
41287 0 : if (!SWIG_IsOK(ecode2)) {
41288 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_topologyPreservingSimplify" "', argument " "2"" of type '" "double""'");
41289 : }
41290 0 : arg2 = (double)(val2);
41291 : {
41292 : result = (shapeObj *)shapeObj_topologyPreservingSimplify(arg1,arg2); {
41293 0 : errorObj *ms_error = msGetErrorObj();
41294 :
41295 0 : switch(ms_error->code) {
41296 : case MS_NOERR:
41297 : break;
41298 0 : case MS_NOTFOUND:
41299 0 : msResetErrorList();
41300 0 : break;
41301 : case -1:
41302 : break;
41303 0 : case MS_IOERR:
41304 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41305 0 : _raise_ms_exception();
41306 0 : msResetErrorList();
41307 0 : return NULL;
41308 : }
41309 : default:
41310 0 : _raise_ms_exception();
41311 0 : msResetErrorList();
41312 0 : return NULL;
41313 : }
41314 :
41315 : }
41316 : }
41317 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41318 0 : return resultobj;
41319 0 : fail:
41320 : return NULL;
41321 : }
41322 :
41323 :
41324 0 : SWIGINTERN PyObject *_wrap_shapeObj_convexHull(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41325 : PyObject *resultobj = 0;
41326 : shapeObj *arg1 = (shapeObj *) 0 ;
41327 0 : void *argp1 = 0 ;
41328 : int res1 = 0 ;
41329 0 : PyObject * obj0 = 0 ;
41330 : shapeObj *result = 0 ;
41331 :
41332 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_convexHull",&obj0)) SWIG_fail;
41333 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41334 0 : if (!SWIG_IsOK(res1)) {
41335 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_convexHull" "', argument " "1"" of type '" "shapeObj *""'");
41336 : }
41337 0 : arg1 = (shapeObj *)(argp1);
41338 : {
41339 : result = (shapeObj *)shapeObj_convexHull(arg1); {
41340 0 : errorObj *ms_error = msGetErrorObj();
41341 :
41342 0 : switch(ms_error->code) {
41343 : case MS_NOERR:
41344 : break;
41345 0 : case MS_NOTFOUND:
41346 0 : msResetErrorList();
41347 0 : break;
41348 : case -1:
41349 : break;
41350 0 : case MS_IOERR:
41351 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41352 0 : _raise_ms_exception();
41353 0 : msResetErrorList();
41354 0 : return NULL;
41355 : }
41356 : default:
41357 0 : _raise_ms_exception();
41358 0 : msResetErrorList();
41359 0 : return NULL;
41360 : }
41361 :
41362 : }
41363 : }
41364 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41365 0 : return resultobj;
41366 0 : fail:
41367 : return NULL;
41368 : }
41369 :
41370 :
41371 0 : SWIGINTERN PyObject *_wrap_shapeObj_boundary(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41372 : PyObject *resultobj = 0;
41373 : shapeObj *arg1 = (shapeObj *) 0 ;
41374 0 : void *argp1 = 0 ;
41375 : int res1 = 0 ;
41376 0 : PyObject * obj0 = 0 ;
41377 : shapeObj *result = 0 ;
41378 :
41379 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_boundary",&obj0)) SWIG_fail;
41380 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41381 0 : if (!SWIG_IsOK(res1)) {
41382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_boundary" "', argument " "1"" of type '" "shapeObj *""'");
41383 : }
41384 0 : arg1 = (shapeObj *)(argp1);
41385 : {
41386 : result = (shapeObj *)shapeObj_boundary(arg1); {
41387 0 : errorObj *ms_error = msGetErrorObj();
41388 :
41389 0 : switch(ms_error->code) {
41390 : case MS_NOERR:
41391 : break;
41392 0 : case MS_NOTFOUND:
41393 0 : msResetErrorList();
41394 0 : break;
41395 : case -1:
41396 : break;
41397 0 : case MS_IOERR:
41398 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41399 0 : _raise_ms_exception();
41400 0 : msResetErrorList();
41401 0 : return NULL;
41402 : }
41403 : default:
41404 0 : _raise_ms_exception();
41405 0 : msResetErrorList();
41406 0 : return NULL;
41407 : }
41408 :
41409 : }
41410 : }
41411 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41412 0 : return resultobj;
41413 0 : fail:
41414 : return NULL;
41415 : }
41416 :
41417 :
41418 0 : SWIGINTERN PyObject *_wrap_shapeObj_getCentroid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41419 : PyObject *resultobj = 0;
41420 : shapeObj *arg1 = (shapeObj *) 0 ;
41421 0 : void *argp1 = 0 ;
41422 : int res1 = 0 ;
41423 0 : PyObject * obj0 = 0 ;
41424 : pointObj *result = 0 ;
41425 :
41426 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getCentroid",&obj0)) SWIG_fail;
41427 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41428 0 : if (!SWIG_IsOK(res1)) {
41429 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getCentroid" "', argument " "1"" of type '" "shapeObj *""'");
41430 : }
41431 0 : arg1 = (shapeObj *)(argp1);
41432 : {
41433 : result = (pointObj *)shapeObj_getCentroid(arg1); {
41434 0 : errorObj *ms_error = msGetErrorObj();
41435 :
41436 0 : switch(ms_error->code) {
41437 : case MS_NOERR:
41438 : break;
41439 0 : case MS_NOTFOUND:
41440 0 : msResetErrorList();
41441 0 : break;
41442 : case -1:
41443 : break;
41444 0 : case MS_IOERR:
41445 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41446 0 : _raise_ms_exception();
41447 0 : msResetErrorList();
41448 0 : return NULL;
41449 : }
41450 : default:
41451 0 : _raise_ms_exception();
41452 0 : msResetErrorList();
41453 0 : return NULL;
41454 : }
41455 :
41456 : }
41457 : }
41458 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN | 0 );
41459 0 : return resultobj;
41460 0 : fail:
41461 : return NULL;
41462 : }
41463 :
41464 :
41465 0 : SWIGINTERN PyObject *_wrap_shapeObj_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41466 : PyObject *resultobj = 0;
41467 : shapeObj *arg1 = (shapeObj *) 0 ;
41468 : shapeObj *arg2 = (shapeObj *) 0 ;
41469 0 : void *argp1 = 0 ;
41470 : int res1 = 0 ;
41471 0 : void *argp2 = 0 ;
41472 : int res2 = 0 ;
41473 0 : PyObject * obj0 = 0 ;
41474 0 : PyObject * obj1 = 0 ;
41475 : shapeObj *result = 0 ;
41476 :
41477 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_Union",&obj0,&obj1)) SWIG_fail;
41478 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41479 0 : if (!SWIG_IsOK(res1)) {
41480 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_Union" "', argument " "1"" of type '" "shapeObj *""'");
41481 : }
41482 0 : arg1 = (shapeObj *)(argp1);
41483 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41484 0 : if (!SWIG_IsOK(res2)) {
41485 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_Union" "', argument " "2"" of type '" "shapeObj *""'");
41486 : }
41487 0 : arg2 = (shapeObj *)(argp2);
41488 : {
41489 : result = (shapeObj *)shapeObj_Union(arg1,arg2); {
41490 0 : errorObj *ms_error = msGetErrorObj();
41491 :
41492 0 : switch(ms_error->code) {
41493 : case MS_NOERR:
41494 : break;
41495 0 : case MS_NOTFOUND:
41496 0 : msResetErrorList();
41497 0 : break;
41498 : case -1:
41499 : break;
41500 0 : case MS_IOERR:
41501 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41502 0 : _raise_ms_exception();
41503 0 : msResetErrorList();
41504 0 : return NULL;
41505 : }
41506 : default:
41507 0 : _raise_ms_exception();
41508 0 : msResetErrorList();
41509 0 : return NULL;
41510 : }
41511 :
41512 : }
41513 : }
41514 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41515 0 : return resultobj;
41516 0 : fail:
41517 : return NULL;
41518 : }
41519 :
41520 :
41521 0 : SWIGINTERN PyObject *_wrap_shapeObj_intersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41522 : PyObject *resultobj = 0;
41523 : shapeObj *arg1 = (shapeObj *) 0 ;
41524 : shapeObj *arg2 = (shapeObj *) 0 ;
41525 0 : void *argp1 = 0 ;
41526 : int res1 = 0 ;
41527 0 : void *argp2 = 0 ;
41528 : int res2 = 0 ;
41529 0 : PyObject * obj0 = 0 ;
41530 0 : PyObject * obj1 = 0 ;
41531 : shapeObj *result = 0 ;
41532 :
41533 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_intersection",&obj0,&obj1)) SWIG_fail;
41534 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41535 0 : if (!SWIG_IsOK(res1)) {
41536 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_intersection" "', argument " "1"" of type '" "shapeObj *""'");
41537 : }
41538 0 : arg1 = (shapeObj *)(argp1);
41539 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41540 0 : if (!SWIG_IsOK(res2)) {
41541 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_intersection" "', argument " "2"" of type '" "shapeObj *""'");
41542 : }
41543 0 : arg2 = (shapeObj *)(argp2);
41544 : {
41545 : result = (shapeObj *)shapeObj_intersection(arg1,arg2); {
41546 0 : errorObj *ms_error = msGetErrorObj();
41547 :
41548 0 : switch(ms_error->code) {
41549 : case MS_NOERR:
41550 : break;
41551 0 : case MS_NOTFOUND:
41552 0 : msResetErrorList();
41553 0 : break;
41554 : case -1:
41555 : break;
41556 0 : case MS_IOERR:
41557 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41558 0 : _raise_ms_exception();
41559 0 : msResetErrorList();
41560 0 : return NULL;
41561 : }
41562 : default:
41563 0 : _raise_ms_exception();
41564 0 : msResetErrorList();
41565 0 : return NULL;
41566 : }
41567 :
41568 : }
41569 : }
41570 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41571 0 : return resultobj;
41572 0 : fail:
41573 : return NULL;
41574 : }
41575 :
41576 :
41577 0 : SWIGINTERN PyObject *_wrap_shapeObj_difference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41578 : PyObject *resultobj = 0;
41579 : shapeObj *arg1 = (shapeObj *) 0 ;
41580 : shapeObj *arg2 = (shapeObj *) 0 ;
41581 0 : void *argp1 = 0 ;
41582 : int res1 = 0 ;
41583 0 : void *argp2 = 0 ;
41584 : int res2 = 0 ;
41585 0 : PyObject * obj0 = 0 ;
41586 0 : PyObject * obj1 = 0 ;
41587 : shapeObj *result = 0 ;
41588 :
41589 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_difference",&obj0,&obj1)) SWIG_fail;
41590 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41591 0 : if (!SWIG_IsOK(res1)) {
41592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_difference" "', argument " "1"" of type '" "shapeObj *""'");
41593 : }
41594 0 : arg1 = (shapeObj *)(argp1);
41595 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41596 0 : if (!SWIG_IsOK(res2)) {
41597 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_difference" "', argument " "2"" of type '" "shapeObj *""'");
41598 : }
41599 0 : arg2 = (shapeObj *)(argp2);
41600 : {
41601 : result = (shapeObj *)shapeObj_difference(arg1,arg2); {
41602 0 : errorObj *ms_error = msGetErrorObj();
41603 :
41604 0 : switch(ms_error->code) {
41605 : case MS_NOERR:
41606 : break;
41607 0 : case MS_NOTFOUND:
41608 0 : msResetErrorList();
41609 0 : break;
41610 : case -1:
41611 : break;
41612 0 : case MS_IOERR:
41613 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41614 0 : _raise_ms_exception();
41615 0 : msResetErrorList();
41616 0 : return NULL;
41617 : }
41618 : default:
41619 0 : _raise_ms_exception();
41620 0 : msResetErrorList();
41621 0 : return NULL;
41622 : }
41623 :
41624 : }
41625 : }
41626 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41627 0 : return resultobj;
41628 0 : fail:
41629 : return NULL;
41630 : }
41631 :
41632 :
41633 0 : SWIGINTERN PyObject *_wrap_shapeObj_symDifference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41634 : PyObject *resultobj = 0;
41635 : shapeObj *arg1 = (shapeObj *) 0 ;
41636 : shapeObj *arg2 = (shapeObj *) 0 ;
41637 0 : void *argp1 = 0 ;
41638 : int res1 = 0 ;
41639 0 : void *argp2 = 0 ;
41640 : int res2 = 0 ;
41641 0 : PyObject * obj0 = 0 ;
41642 0 : PyObject * obj1 = 0 ;
41643 : shapeObj *result = 0 ;
41644 :
41645 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_symDifference",&obj0,&obj1)) SWIG_fail;
41646 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41647 0 : if (!SWIG_IsOK(res1)) {
41648 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_symDifference" "', argument " "1"" of type '" "shapeObj *""'");
41649 : }
41650 0 : arg1 = (shapeObj *)(argp1);
41651 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41652 0 : if (!SWIG_IsOK(res2)) {
41653 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_symDifference" "', argument " "2"" of type '" "shapeObj *""'");
41654 : }
41655 0 : arg2 = (shapeObj *)(argp2);
41656 : {
41657 : result = (shapeObj *)shapeObj_symDifference(arg1,arg2); {
41658 0 : errorObj *ms_error = msGetErrorObj();
41659 :
41660 0 : switch(ms_error->code) {
41661 : case MS_NOERR:
41662 : break;
41663 0 : case MS_NOTFOUND:
41664 0 : msResetErrorList();
41665 0 : break;
41666 : case -1:
41667 : break;
41668 0 : case MS_IOERR:
41669 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41670 0 : _raise_ms_exception();
41671 0 : msResetErrorList();
41672 0 : return NULL;
41673 : }
41674 : default:
41675 0 : _raise_ms_exception();
41676 0 : msResetErrorList();
41677 0 : return NULL;
41678 : }
41679 :
41680 : }
41681 : }
41682 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
41683 0 : return resultobj;
41684 0 : fail:
41685 : return NULL;
41686 : }
41687 :
41688 :
41689 0 : SWIGINTERN PyObject *_wrap_shapeObj_contains__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41690 : PyObject *resultobj = 0;
41691 : shapeObj *arg1 = (shapeObj *) 0 ;
41692 : shapeObj *arg2 = (shapeObj *) 0 ;
41693 0 : void *argp1 = 0 ;
41694 : int res1 = 0 ;
41695 0 : void *argp2 = 0 ;
41696 : int res2 = 0 ;
41697 0 : PyObject * obj0 = 0 ;
41698 0 : PyObject * obj1 = 0 ;
41699 : int result;
41700 :
41701 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_contains",&obj0,&obj1)) SWIG_fail;
41702 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41703 0 : if (!SWIG_IsOK(res1)) {
41704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_contains" "', argument " "1"" of type '" "shapeObj *""'");
41705 : }
41706 0 : arg1 = (shapeObj *)(argp1);
41707 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41708 0 : if (!SWIG_IsOK(res2)) {
41709 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_contains" "', argument " "2"" of type '" "shapeObj *""'");
41710 : }
41711 0 : arg2 = (shapeObj *)(argp2);
41712 : {
41713 : result = (int)shapeObj_contains__SWIG_0(arg1,arg2); {
41714 0 : errorObj *ms_error = msGetErrorObj();
41715 :
41716 0 : switch(ms_error->code) {
41717 : case MS_NOERR:
41718 : break;
41719 0 : case MS_NOTFOUND:
41720 0 : msResetErrorList();
41721 : break;
41722 : case -1:
41723 : break;
41724 0 : case MS_IOERR:
41725 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41726 0 : _raise_ms_exception();
41727 0 : msResetErrorList();
41728 : return NULL;
41729 : }
41730 : default:
41731 0 : _raise_ms_exception();
41732 0 : msResetErrorList();
41733 : return NULL;
41734 : }
41735 :
41736 : }
41737 : }
41738 : resultobj = SWIG_From_int((int)(result));
41739 : return resultobj;
41740 : fail:
41741 : return NULL;
41742 : }
41743 :
41744 :
41745 0 : SWIGINTERN PyObject *_wrap_shapeObj_overlaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41746 : PyObject *resultobj = 0;
41747 : shapeObj *arg1 = (shapeObj *) 0 ;
41748 : shapeObj *arg2 = (shapeObj *) 0 ;
41749 0 : void *argp1 = 0 ;
41750 : int res1 = 0 ;
41751 0 : void *argp2 = 0 ;
41752 : int res2 = 0 ;
41753 0 : PyObject * obj0 = 0 ;
41754 0 : PyObject * obj1 = 0 ;
41755 : int result;
41756 :
41757 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_overlaps",&obj0,&obj1)) SWIG_fail;
41758 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41759 0 : if (!SWIG_IsOK(res1)) {
41760 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_overlaps" "', argument " "1"" of type '" "shapeObj *""'");
41761 : }
41762 0 : arg1 = (shapeObj *)(argp1);
41763 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41764 0 : if (!SWIG_IsOK(res2)) {
41765 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_overlaps" "', argument " "2"" of type '" "shapeObj *""'");
41766 : }
41767 0 : arg2 = (shapeObj *)(argp2);
41768 : {
41769 : result = (int)shapeObj_overlaps(arg1,arg2); {
41770 0 : errorObj *ms_error = msGetErrorObj();
41771 :
41772 0 : switch(ms_error->code) {
41773 : case MS_NOERR:
41774 : break;
41775 0 : case MS_NOTFOUND:
41776 0 : msResetErrorList();
41777 0 : break;
41778 : case -1:
41779 : break;
41780 0 : case MS_IOERR:
41781 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41782 0 : _raise_ms_exception();
41783 0 : msResetErrorList();
41784 0 : return NULL;
41785 : }
41786 : default:
41787 0 : _raise_ms_exception();
41788 0 : msResetErrorList();
41789 0 : return NULL;
41790 : }
41791 :
41792 : }
41793 : }
41794 : resultobj = SWIG_From_int((int)(result));
41795 0 : return resultobj;
41796 0 : fail:
41797 : return NULL;
41798 : }
41799 :
41800 :
41801 0 : SWIGINTERN PyObject *_wrap_shapeObj_within(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41802 : PyObject *resultobj = 0;
41803 : shapeObj *arg1 = (shapeObj *) 0 ;
41804 : shapeObj *arg2 = (shapeObj *) 0 ;
41805 0 : void *argp1 = 0 ;
41806 : int res1 = 0 ;
41807 0 : void *argp2 = 0 ;
41808 : int res2 = 0 ;
41809 0 : PyObject * obj0 = 0 ;
41810 0 : PyObject * obj1 = 0 ;
41811 : int result;
41812 :
41813 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_within",&obj0,&obj1)) SWIG_fail;
41814 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41815 0 : if (!SWIG_IsOK(res1)) {
41816 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_within" "', argument " "1"" of type '" "shapeObj *""'");
41817 : }
41818 0 : arg1 = (shapeObj *)(argp1);
41819 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41820 0 : if (!SWIG_IsOK(res2)) {
41821 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_within" "', argument " "2"" of type '" "shapeObj *""'");
41822 : }
41823 0 : arg2 = (shapeObj *)(argp2);
41824 : {
41825 : result = (int)shapeObj_within(arg1,arg2); {
41826 0 : errorObj *ms_error = msGetErrorObj();
41827 :
41828 0 : switch(ms_error->code) {
41829 : case MS_NOERR:
41830 : break;
41831 0 : case MS_NOTFOUND:
41832 0 : msResetErrorList();
41833 0 : break;
41834 : case -1:
41835 : break;
41836 0 : case MS_IOERR:
41837 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41838 0 : _raise_ms_exception();
41839 0 : msResetErrorList();
41840 0 : return NULL;
41841 : }
41842 : default:
41843 0 : _raise_ms_exception();
41844 0 : msResetErrorList();
41845 0 : return NULL;
41846 : }
41847 :
41848 : }
41849 : }
41850 : resultobj = SWIG_From_int((int)(result));
41851 0 : return resultobj;
41852 0 : fail:
41853 : return NULL;
41854 : }
41855 :
41856 :
41857 0 : SWIGINTERN PyObject *_wrap_shapeObj_crosses(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41858 : PyObject *resultobj = 0;
41859 : shapeObj *arg1 = (shapeObj *) 0 ;
41860 : shapeObj *arg2 = (shapeObj *) 0 ;
41861 0 : void *argp1 = 0 ;
41862 : int res1 = 0 ;
41863 0 : void *argp2 = 0 ;
41864 : int res2 = 0 ;
41865 0 : PyObject * obj0 = 0 ;
41866 0 : PyObject * obj1 = 0 ;
41867 : int result;
41868 :
41869 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_crosses",&obj0,&obj1)) SWIG_fail;
41870 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41871 0 : if (!SWIG_IsOK(res1)) {
41872 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_crosses" "', argument " "1"" of type '" "shapeObj *""'");
41873 : }
41874 0 : arg1 = (shapeObj *)(argp1);
41875 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41876 0 : if (!SWIG_IsOK(res2)) {
41877 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_crosses" "', argument " "2"" of type '" "shapeObj *""'");
41878 : }
41879 0 : arg2 = (shapeObj *)(argp2);
41880 : {
41881 : result = (int)shapeObj_crosses(arg1,arg2); {
41882 0 : errorObj *ms_error = msGetErrorObj();
41883 :
41884 0 : switch(ms_error->code) {
41885 : case MS_NOERR:
41886 : break;
41887 0 : case MS_NOTFOUND:
41888 0 : msResetErrorList();
41889 0 : break;
41890 : case -1:
41891 : break;
41892 0 : case MS_IOERR:
41893 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41894 0 : _raise_ms_exception();
41895 0 : msResetErrorList();
41896 0 : return NULL;
41897 : }
41898 : default:
41899 0 : _raise_ms_exception();
41900 0 : msResetErrorList();
41901 0 : return NULL;
41902 : }
41903 :
41904 : }
41905 : }
41906 : resultobj = SWIG_From_int((int)(result));
41907 0 : return resultobj;
41908 0 : fail:
41909 : return NULL;
41910 : }
41911 :
41912 :
41913 0 : SWIGINTERN PyObject *_wrap_shapeObj_intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41914 : PyObject *resultobj = 0;
41915 : shapeObj *arg1 = (shapeObj *) 0 ;
41916 : shapeObj *arg2 = (shapeObj *) 0 ;
41917 0 : void *argp1 = 0 ;
41918 : int res1 = 0 ;
41919 0 : void *argp2 = 0 ;
41920 : int res2 = 0 ;
41921 0 : PyObject * obj0 = 0 ;
41922 0 : PyObject * obj1 = 0 ;
41923 : int result;
41924 :
41925 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_intersects",&obj0,&obj1)) SWIG_fail;
41926 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41927 0 : if (!SWIG_IsOK(res1)) {
41928 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_intersects" "', argument " "1"" of type '" "shapeObj *""'");
41929 : }
41930 0 : arg1 = (shapeObj *)(argp1);
41931 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41932 0 : if (!SWIG_IsOK(res2)) {
41933 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_intersects" "', argument " "2"" of type '" "shapeObj *""'");
41934 : }
41935 0 : arg2 = (shapeObj *)(argp2);
41936 : {
41937 : result = (int)shapeObj_intersects(arg1,arg2); {
41938 0 : errorObj *ms_error = msGetErrorObj();
41939 :
41940 0 : switch(ms_error->code) {
41941 : case MS_NOERR:
41942 : break;
41943 0 : case MS_NOTFOUND:
41944 0 : msResetErrorList();
41945 0 : break;
41946 : case -1:
41947 : break;
41948 0 : case MS_IOERR:
41949 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
41950 0 : _raise_ms_exception();
41951 0 : msResetErrorList();
41952 0 : return NULL;
41953 : }
41954 : default:
41955 0 : _raise_ms_exception();
41956 0 : msResetErrorList();
41957 0 : return NULL;
41958 : }
41959 :
41960 : }
41961 : }
41962 : resultobj = SWIG_From_int((int)(result));
41963 0 : return resultobj;
41964 0 : fail:
41965 : return NULL;
41966 : }
41967 :
41968 :
41969 0 : SWIGINTERN PyObject *_wrap_shapeObj_touches(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41970 : PyObject *resultobj = 0;
41971 : shapeObj *arg1 = (shapeObj *) 0 ;
41972 : shapeObj *arg2 = (shapeObj *) 0 ;
41973 0 : void *argp1 = 0 ;
41974 : int res1 = 0 ;
41975 0 : void *argp2 = 0 ;
41976 : int res2 = 0 ;
41977 0 : PyObject * obj0 = 0 ;
41978 0 : PyObject * obj1 = 0 ;
41979 : int result;
41980 :
41981 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_touches",&obj0,&obj1)) SWIG_fail;
41982 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
41983 0 : if (!SWIG_IsOK(res1)) {
41984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_touches" "', argument " "1"" of type '" "shapeObj *""'");
41985 : }
41986 0 : arg1 = (shapeObj *)(argp1);
41987 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
41988 0 : if (!SWIG_IsOK(res2)) {
41989 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_touches" "', argument " "2"" of type '" "shapeObj *""'");
41990 : }
41991 0 : arg2 = (shapeObj *)(argp2);
41992 : {
41993 : result = (int)shapeObj_touches(arg1,arg2); {
41994 0 : errorObj *ms_error = msGetErrorObj();
41995 :
41996 0 : switch(ms_error->code) {
41997 : case MS_NOERR:
41998 : break;
41999 0 : case MS_NOTFOUND:
42000 0 : msResetErrorList();
42001 0 : break;
42002 : case -1:
42003 : break;
42004 0 : case MS_IOERR:
42005 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42006 0 : _raise_ms_exception();
42007 0 : msResetErrorList();
42008 0 : return NULL;
42009 : }
42010 : default:
42011 0 : _raise_ms_exception();
42012 0 : msResetErrorList();
42013 0 : return NULL;
42014 : }
42015 :
42016 : }
42017 : }
42018 : resultobj = SWIG_From_int((int)(result));
42019 0 : return resultobj;
42020 0 : fail:
42021 : return NULL;
42022 : }
42023 :
42024 :
42025 0 : SWIGINTERN PyObject *_wrap_shapeObj_equals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42026 : PyObject *resultobj = 0;
42027 : shapeObj *arg1 = (shapeObj *) 0 ;
42028 : shapeObj *arg2 = (shapeObj *) 0 ;
42029 0 : void *argp1 = 0 ;
42030 : int res1 = 0 ;
42031 0 : void *argp2 = 0 ;
42032 : int res2 = 0 ;
42033 0 : PyObject * obj0 = 0 ;
42034 0 : PyObject * obj1 = 0 ;
42035 : int result;
42036 :
42037 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_equals",&obj0,&obj1)) SWIG_fail;
42038 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42039 0 : if (!SWIG_IsOK(res1)) {
42040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_equals" "', argument " "1"" of type '" "shapeObj *""'");
42041 : }
42042 0 : arg1 = (shapeObj *)(argp1);
42043 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
42044 0 : if (!SWIG_IsOK(res2)) {
42045 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_equals" "', argument " "2"" of type '" "shapeObj *""'");
42046 : }
42047 0 : arg2 = (shapeObj *)(argp2);
42048 : {
42049 : result = (int)shapeObj_equals(arg1,arg2); {
42050 0 : errorObj *ms_error = msGetErrorObj();
42051 :
42052 0 : switch(ms_error->code) {
42053 : case MS_NOERR:
42054 : break;
42055 0 : case MS_NOTFOUND:
42056 0 : msResetErrorList();
42057 0 : break;
42058 : case -1:
42059 : break;
42060 0 : case MS_IOERR:
42061 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42062 0 : _raise_ms_exception();
42063 0 : msResetErrorList();
42064 0 : return NULL;
42065 : }
42066 : default:
42067 0 : _raise_ms_exception();
42068 0 : msResetErrorList();
42069 0 : return NULL;
42070 : }
42071 :
42072 : }
42073 : }
42074 : resultobj = SWIG_From_int((int)(result));
42075 0 : return resultobj;
42076 0 : fail:
42077 : return NULL;
42078 : }
42079 :
42080 :
42081 0 : SWIGINTERN PyObject *_wrap_shapeObj_disjoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42082 : PyObject *resultobj = 0;
42083 : shapeObj *arg1 = (shapeObj *) 0 ;
42084 : shapeObj *arg2 = (shapeObj *) 0 ;
42085 0 : void *argp1 = 0 ;
42086 : int res1 = 0 ;
42087 0 : void *argp2 = 0 ;
42088 : int res2 = 0 ;
42089 0 : PyObject * obj0 = 0 ;
42090 0 : PyObject * obj1 = 0 ;
42091 : int result;
42092 :
42093 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_disjoint",&obj0,&obj1)) SWIG_fail;
42094 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42095 0 : if (!SWIG_IsOK(res1)) {
42096 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_disjoint" "', argument " "1"" of type '" "shapeObj *""'");
42097 : }
42098 0 : arg1 = (shapeObj *)(argp1);
42099 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
42100 0 : if (!SWIG_IsOK(res2)) {
42101 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_disjoint" "', argument " "2"" of type '" "shapeObj *""'");
42102 : }
42103 0 : arg2 = (shapeObj *)(argp2);
42104 : {
42105 : result = (int)shapeObj_disjoint(arg1,arg2); {
42106 0 : errorObj *ms_error = msGetErrorObj();
42107 :
42108 0 : switch(ms_error->code) {
42109 : case MS_NOERR:
42110 : break;
42111 0 : case MS_NOTFOUND:
42112 0 : msResetErrorList();
42113 0 : break;
42114 : case -1:
42115 : break;
42116 0 : case MS_IOERR:
42117 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42118 0 : _raise_ms_exception();
42119 0 : msResetErrorList();
42120 0 : return NULL;
42121 : }
42122 : default:
42123 0 : _raise_ms_exception();
42124 0 : msResetErrorList();
42125 0 : return NULL;
42126 : }
42127 :
42128 : }
42129 : }
42130 : resultobj = SWIG_From_int((int)(result));
42131 0 : return resultobj;
42132 0 : fail:
42133 : return NULL;
42134 : }
42135 :
42136 :
42137 0 : SWIGINTERN PyObject *_wrap_shapeObj_getArea(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42138 : PyObject *resultobj = 0;
42139 : shapeObj *arg1 = (shapeObj *) 0 ;
42140 0 : void *argp1 = 0 ;
42141 : int res1 = 0 ;
42142 0 : PyObject * obj0 = 0 ;
42143 : double result;
42144 :
42145 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getArea",&obj0)) SWIG_fail;
42146 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42147 0 : if (!SWIG_IsOK(res1)) {
42148 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getArea" "', argument " "1"" of type '" "shapeObj *""'");
42149 : }
42150 0 : arg1 = (shapeObj *)(argp1);
42151 : {
42152 : result = (double)shapeObj_getArea(arg1); {
42153 0 : errorObj *ms_error = msGetErrorObj();
42154 :
42155 0 : switch(ms_error->code) {
42156 : case MS_NOERR:
42157 : break;
42158 0 : case MS_NOTFOUND:
42159 0 : msResetErrorList();
42160 0 : break;
42161 : case -1:
42162 : break;
42163 0 : case MS_IOERR:
42164 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42165 0 : _raise_ms_exception();
42166 0 : msResetErrorList();
42167 0 : return NULL;
42168 : }
42169 : default:
42170 0 : _raise_ms_exception();
42171 0 : msResetErrorList();
42172 0 : return NULL;
42173 : }
42174 :
42175 : }
42176 : }
42177 0 : resultobj = SWIG_From_double((double)(result));
42178 0 : return resultobj;
42179 0 : fail:
42180 : return NULL;
42181 : }
42182 :
42183 :
42184 0 : SWIGINTERN PyObject *_wrap_shapeObj_getLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42185 : PyObject *resultobj = 0;
42186 : shapeObj *arg1 = (shapeObj *) 0 ;
42187 0 : void *argp1 = 0 ;
42188 : int res1 = 0 ;
42189 0 : PyObject * obj0 = 0 ;
42190 : double result;
42191 :
42192 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getLength",&obj0)) SWIG_fail;
42193 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42194 0 : if (!SWIG_IsOK(res1)) {
42195 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getLength" "', argument " "1"" of type '" "shapeObj *""'");
42196 : }
42197 0 : arg1 = (shapeObj *)(argp1);
42198 : {
42199 : result = (double)shapeObj_getLength(arg1); {
42200 0 : errorObj *ms_error = msGetErrorObj();
42201 :
42202 0 : switch(ms_error->code) {
42203 : case MS_NOERR:
42204 : break;
42205 0 : case MS_NOTFOUND:
42206 0 : msResetErrorList();
42207 0 : break;
42208 : case -1:
42209 : break;
42210 0 : case MS_IOERR:
42211 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42212 0 : _raise_ms_exception();
42213 0 : msResetErrorList();
42214 0 : return NULL;
42215 : }
42216 : default:
42217 0 : _raise_ms_exception();
42218 0 : msResetErrorList();
42219 0 : return NULL;
42220 : }
42221 :
42222 : }
42223 : }
42224 0 : resultobj = SWIG_From_double((double)(result));
42225 0 : return resultobj;
42226 0 : fail:
42227 : return NULL;
42228 : }
42229 :
42230 :
42231 1 : SWIGINTERN PyObject *_wrap_shapeObj_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42232 : PyObject *resultobj = 0;
42233 : shapeObj *arg1 = (shapeObj *) 0 ;
42234 : int arg2 ;
42235 1 : void *argp1 = 0 ;
42236 : int res1 = 0 ;
42237 : int val2 ;
42238 : int ecode2 = 0 ;
42239 1 : PyObject * obj0 = 0 ;
42240 1 : PyObject * obj1 = 0 ;
42241 : char *result = 0 ;
42242 :
42243 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_getValue",&obj0,&obj1)) SWIG_fail;
42244 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42245 1 : if (!SWIG_IsOK(res1)) {
42246 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getValue" "', argument " "1"" of type '" "shapeObj *""'");
42247 : }
42248 1 : arg1 = (shapeObj *)(argp1);
42249 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42250 1 : if (!SWIG_IsOK(ecode2)) {
42251 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_getValue" "', argument " "2"" of type '" "int""'");
42252 : }
42253 : arg2 = (int)(val2);
42254 : {
42255 : result = (char *)shapeObj_getValue(arg1,arg2); {
42256 1 : errorObj *ms_error = msGetErrorObj();
42257 :
42258 1 : switch(ms_error->code) {
42259 : case MS_NOERR:
42260 : break;
42261 0 : case MS_NOTFOUND:
42262 0 : msResetErrorList();
42263 0 : break;
42264 : case -1:
42265 : break;
42266 0 : case MS_IOERR:
42267 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42268 0 : _raise_ms_exception();
42269 0 : msResetErrorList();
42270 0 : return NULL;
42271 : }
42272 : default:
42273 0 : _raise_ms_exception();
42274 0 : msResetErrorList();
42275 0 : return NULL;
42276 : }
42277 :
42278 : }
42279 : }
42280 1 : resultobj = SWIG_FromCharPtr((const char *)result);
42281 1 : return resultobj;
42282 0 : fail:
42283 : return NULL;
42284 : }
42285 :
42286 :
42287 0 : SWIGINTERN PyObject *_wrap_shapeObj_contains__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42288 : PyObject *resultobj = 0;
42289 : shapeObj *arg1 = (shapeObj *) 0 ;
42290 : pointObj *arg2 = (pointObj *) 0 ;
42291 0 : void *argp1 = 0 ;
42292 : int res1 = 0 ;
42293 0 : void *argp2 = 0 ;
42294 : int res2 = 0 ;
42295 0 : PyObject * obj0 = 0 ;
42296 0 : PyObject * obj1 = 0 ;
42297 : int result;
42298 :
42299 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_contains",&obj0,&obj1)) SWIG_fail;
42300 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42301 0 : if (!SWIG_IsOK(res1)) {
42302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_contains" "', argument " "1"" of type '" "shapeObj *""'");
42303 : }
42304 0 : arg1 = (shapeObj *)(argp1);
42305 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
42306 0 : if (!SWIG_IsOK(res2)) {
42307 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_contains" "', argument " "2"" of type '" "pointObj *""'");
42308 : }
42309 0 : arg2 = (pointObj *)(argp2);
42310 : {
42311 : result = (int)shapeObj_contains__SWIG_1(arg1,arg2); {
42312 0 : errorObj *ms_error = msGetErrorObj();
42313 :
42314 0 : switch(ms_error->code) {
42315 : case MS_NOERR:
42316 : break;
42317 0 : case MS_NOTFOUND:
42318 0 : msResetErrorList();
42319 : break;
42320 : case -1:
42321 : break;
42322 0 : case MS_IOERR:
42323 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42324 0 : _raise_ms_exception();
42325 0 : msResetErrorList();
42326 : return NULL;
42327 : }
42328 : default:
42329 0 : _raise_ms_exception();
42330 0 : msResetErrorList();
42331 : return NULL;
42332 : }
42333 :
42334 : }
42335 : }
42336 : resultobj = SWIG_From_int((int)(result));
42337 : return resultobj;
42338 : fail:
42339 : return NULL;
42340 : }
42341 :
42342 :
42343 0 : SWIGINTERN PyObject *_wrap_shapeObj_contains(PyObject *self, PyObject *args) {
42344 : Py_ssize_t argc;
42345 0 : PyObject *argv[3] = {
42346 : 0
42347 : };
42348 : Py_ssize_t ii;
42349 :
42350 0 : if (!PyTuple_Check(args)) SWIG_fail;
42351 0 : argc = args ? PyObject_Length(args) : 0;
42352 0 : for (ii = 0; (ii < 2) && (ii < argc); ii++) {
42353 0 : argv[ii] = PyTuple_GET_ITEM(args,ii);
42354 : }
42355 0 : if (argc == 2) {
42356 : int _v;
42357 0 : void *vptr = 0;
42358 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_shapeObj, 0);
42359 : _v = SWIG_CheckState(res);
42360 0 : if (_v) {
42361 0 : void *vptr = 0;
42362 0 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_shapeObj, 0);
42363 : _v = SWIG_CheckState(res);
42364 0 : if (_v) {
42365 0 : return _wrap_shapeObj_contains__SWIG_0(self, args);
42366 : }
42367 : }
42368 : }
42369 0 : if (argc == 2) {
42370 : int _v;
42371 0 : void *vptr = 0;
42372 0 : int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_shapeObj, 0);
42373 : _v = SWIG_CheckState(res);
42374 0 : if (_v) {
42375 0 : void *vptr = 0;
42376 0 : int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_pointObj, 0);
42377 : _v = SWIG_CheckState(res);
42378 0 : if (_v) {
42379 0 : return _wrap_shapeObj_contains__SWIG_1(self, args);
42380 : }
42381 : }
42382 : }
42383 :
42384 0 : fail:
42385 0 : SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number or type of arguments for overloaded function 'shapeObj_contains'.\n"
42386 : " Possible C/C++ prototypes are:\n"
42387 : " shapeObj::contains(shapeObj *)\n"
42388 : " shapeObj::contains(pointObj *)\n");
42389 0 : return 0;
42390 : }
42391 :
42392 :
42393 0 : SWIGINTERN PyObject *_wrap_shapeObj_distanceToPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42394 : PyObject *resultobj = 0;
42395 : shapeObj *arg1 = (shapeObj *) 0 ;
42396 : pointObj *arg2 = (pointObj *) 0 ;
42397 0 : void *argp1 = 0 ;
42398 : int res1 = 0 ;
42399 0 : void *argp2 = 0 ;
42400 : int res2 = 0 ;
42401 0 : PyObject * obj0 = 0 ;
42402 0 : PyObject * obj1 = 0 ;
42403 : double result;
42404 :
42405 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_distanceToPoint",&obj0,&obj1)) SWIG_fail;
42406 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42407 0 : if (!SWIG_IsOK(res1)) {
42408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_distanceToPoint" "', argument " "1"" of type '" "shapeObj *""'");
42409 : }
42410 0 : arg1 = (shapeObj *)(argp1);
42411 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
42412 0 : if (!SWIG_IsOK(res2)) {
42413 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_distanceToPoint" "', argument " "2"" of type '" "pointObj *""'");
42414 : }
42415 0 : arg2 = (pointObj *)(argp2);
42416 : {
42417 : result = (double)shapeObj_distanceToPoint(arg1,arg2); {
42418 0 : errorObj *ms_error = msGetErrorObj();
42419 :
42420 0 : switch(ms_error->code) {
42421 : case MS_NOERR:
42422 : break;
42423 0 : case MS_NOTFOUND:
42424 0 : msResetErrorList();
42425 0 : break;
42426 : case -1:
42427 : break;
42428 0 : case MS_IOERR:
42429 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42430 0 : _raise_ms_exception();
42431 0 : msResetErrorList();
42432 0 : return NULL;
42433 : }
42434 : default:
42435 0 : _raise_ms_exception();
42436 0 : msResetErrorList();
42437 0 : return NULL;
42438 : }
42439 :
42440 : }
42441 : }
42442 0 : resultobj = SWIG_From_double((double)(result));
42443 0 : return resultobj;
42444 0 : fail:
42445 : return NULL;
42446 : }
42447 :
42448 :
42449 0 : SWIGINTERN PyObject *_wrap_shapeObj_distanceToShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42450 : PyObject *resultobj = 0;
42451 : shapeObj *arg1 = (shapeObj *) 0 ;
42452 : shapeObj *arg2 = (shapeObj *) 0 ;
42453 0 : void *argp1 = 0 ;
42454 : int res1 = 0 ;
42455 0 : void *argp2 = 0 ;
42456 : int res2 = 0 ;
42457 0 : PyObject * obj0 = 0 ;
42458 0 : PyObject * obj1 = 0 ;
42459 : double result;
42460 :
42461 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_distanceToShape",&obj0,&obj1)) SWIG_fail;
42462 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42463 0 : if (!SWIG_IsOK(res1)) {
42464 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_distanceToShape" "', argument " "1"" of type '" "shapeObj *""'");
42465 : }
42466 0 : arg1 = (shapeObj *)(argp1);
42467 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
42468 0 : if (!SWIG_IsOK(res2)) {
42469 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapeObj_distanceToShape" "', argument " "2"" of type '" "shapeObj *""'");
42470 : }
42471 0 : arg2 = (shapeObj *)(argp2);
42472 : {
42473 : result = (double)shapeObj_distanceToShape(arg1,arg2); {
42474 0 : errorObj *ms_error = msGetErrorObj();
42475 :
42476 0 : switch(ms_error->code) {
42477 : case MS_NOERR:
42478 : break;
42479 0 : case MS_NOTFOUND:
42480 0 : msResetErrorList();
42481 0 : break;
42482 : case -1:
42483 : break;
42484 0 : case MS_IOERR:
42485 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42486 0 : _raise_ms_exception();
42487 0 : msResetErrorList();
42488 0 : return NULL;
42489 : }
42490 : default:
42491 0 : _raise_ms_exception();
42492 0 : msResetErrorList();
42493 0 : return NULL;
42494 : }
42495 :
42496 : }
42497 : }
42498 0 : resultobj = SWIG_From_double((double)(result));
42499 0 : return resultobj;
42500 0 : fail:
42501 : return NULL;
42502 : }
42503 :
42504 :
42505 0 : SWIGINTERN PyObject *_wrap_shapeObj_getLabelPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42506 : PyObject *resultobj = 0;
42507 : shapeObj *arg1 = (shapeObj *) 0 ;
42508 0 : void *argp1 = 0 ;
42509 : int res1 = 0 ;
42510 0 : PyObject * obj0 = 0 ;
42511 : pointObj *result = 0 ;
42512 :
42513 0 : if (!PyArg_ParseTuple(args,(char *)"O:shapeObj_getLabelPoint",&obj0)) SWIG_fail;
42514 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42515 0 : if (!SWIG_IsOK(res1)) {
42516 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_getLabelPoint" "', argument " "1"" of type '" "shapeObj *""'");
42517 : }
42518 0 : arg1 = (shapeObj *)(argp1);
42519 : {
42520 0 : result = (pointObj *)shapeObj_getLabelPoint(arg1); {
42521 0 : errorObj *ms_error = msGetErrorObj();
42522 :
42523 0 : switch(ms_error->code) {
42524 : case MS_NOERR:
42525 : break;
42526 0 : case MS_NOTFOUND:
42527 0 : msResetErrorList();
42528 0 : break;
42529 : case -1:
42530 : break;
42531 0 : case MS_IOERR:
42532 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42533 0 : _raise_ms_exception();
42534 0 : msResetErrorList();
42535 0 : return NULL;
42536 : }
42537 : default:
42538 0 : _raise_ms_exception();
42539 0 : msResetErrorList();
42540 0 : return NULL;
42541 : }
42542 :
42543 : }
42544 : }
42545 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_pointObj, SWIG_POINTER_OWN | 0 );
42546 0 : return resultobj;
42547 0 : fail:
42548 : return NULL;
42549 : }
42550 :
42551 :
42552 1 : SWIGINTERN PyObject *_wrap_shapeObj_setValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42553 : PyObject *resultobj = 0;
42554 : shapeObj *arg1 = (shapeObj *) 0 ;
42555 : int arg2 ;
42556 : char *arg3 = (char *) 0 ;
42557 1 : void *argp1 = 0 ;
42558 : int res1 = 0 ;
42559 : int val2 ;
42560 : int ecode2 = 0 ;
42561 : int res3 ;
42562 1 : char *buf3 = 0 ;
42563 1 : int alloc3 = 0 ;
42564 1 : PyObject * obj0 = 0 ;
42565 1 : PyObject * obj1 = 0 ;
42566 1 : PyObject * obj2 = 0 ;
42567 : int result;
42568 :
42569 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:shapeObj_setValue",&obj0,&obj1,&obj2)) SWIG_fail;
42570 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42571 1 : if (!SWIG_IsOK(res1)) {
42572 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_setValue" "', argument " "1"" of type '" "shapeObj *""'");
42573 : }
42574 1 : arg1 = (shapeObj *)(argp1);
42575 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42576 1 : if (!SWIG_IsOK(ecode2)) {
42577 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_setValue" "', argument " "2"" of type '" "int""'");
42578 : }
42579 : arg2 = (int)(val2);
42580 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
42581 1 : if (!SWIG_IsOK(res3)) {
42582 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapeObj_setValue" "', argument " "3"" of type '" "char *""'");
42583 : }
42584 1 : arg3 = (char *)(buf3);
42585 : {
42586 1 : result = (int)shapeObj_setValue(arg1,arg2,arg3); {
42587 1 : errorObj *ms_error = msGetErrorObj();
42588 :
42589 1 : switch(ms_error->code) {
42590 : case MS_NOERR:
42591 : break;
42592 0 : case MS_NOTFOUND:
42593 0 : msResetErrorList();
42594 0 : break;
42595 : case -1:
42596 : break;
42597 0 : case MS_IOERR:
42598 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42599 0 : _raise_ms_exception();
42600 0 : msResetErrorList();
42601 0 : return NULL;
42602 : }
42603 : default:
42604 0 : _raise_ms_exception();
42605 0 : msResetErrorList();
42606 0 : return NULL;
42607 : }
42608 :
42609 : }
42610 : }
42611 : resultobj = SWIG_From_int((int)(result));
42612 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
42613 : return resultobj;
42614 0 : fail:
42615 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
42616 : return NULL;
42617 : }
42618 :
42619 :
42620 1 : SWIGINTERN PyObject *_wrap_shapeObj_initValues(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42621 : PyObject *resultobj = 0;
42622 : shapeObj *arg1 = (shapeObj *) 0 ;
42623 : int arg2 ;
42624 1 : void *argp1 = 0 ;
42625 : int res1 = 0 ;
42626 : int val2 ;
42627 : int ecode2 = 0 ;
42628 1 : PyObject * obj0 = 0 ;
42629 1 : PyObject * obj1 = 0 ;
42630 :
42631 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapeObj_initValues",&obj0,&obj1)) SWIG_fail;
42632 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapeObj, 0 | 0 );
42633 1 : if (!SWIG_IsOK(res1)) {
42634 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapeObj_initValues" "', argument " "1"" of type '" "shapeObj *""'");
42635 : }
42636 1 : arg1 = (shapeObj *)(argp1);
42637 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42638 1 : if (!SWIG_IsOK(ecode2)) {
42639 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapeObj_initValues" "', argument " "2"" of type '" "int""'");
42640 : }
42641 : arg2 = (int)(val2);
42642 : {
42643 1 : shapeObj_initValues(arg1,arg2); {
42644 1 : errorObj *ms_error = msGetErrorObj();
42645 :
42646 1 : switch(ms_error->code) {
42647 : case MS_NOERR:
42648 : break;
42649 0 : case MS_NOTFOUND:
42650 0 : msResetErrorList();
42651 0 : break;
42652 : case -1:
42653 : break;
42654 0 : case MS_IOERR:
42655 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42656 0 : _raise_ms_exception();
42657 0 : msResetErrorList();
42658 0 : return NULL;
42659 : }
42660 : default:
42661 0 : _raise_ms_exception();
42662 0 : msResetErrorList();
42663 0 : return NULL;
42664 : }
42665 :
42666 : }
42667 : }
42668 : resultobj = SWIG_Py_Void();
42669 1 : return resultobj;
42670 0 : fail:
42671 : return NULL;
42672 : }
42673 :
42674 :
42675 1 : SWIGINTERN PyObject *shapeObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42676 : PyObject *obj;
42677 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
42678 1 : SWIG_TypeNewClientData(SWIGTYPE_p_shapeObj, SWIG_NewClientData(obj));
42679 1 : return SWIG_Py_Void();
42680 : }
42681 :
42682 0 : SWIGINTERN PyObject *_wrap_errorObj_code_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42683 : PyObject *resultobj = 0;
42684 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42685 : int arg2 ;
42686 0 : void *argp1 = 0 ;
42687 : int res1 = 0 ;
42688 : int val2 ;
42689 : int ecode2 = 0 ;
42690 0 : PyObject * obj0 = 0 ;
42691 0 : PyObject * obj1 = 0 ;
42692 :
42693 0 : if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_code_set",&obj0,&obj1)) SWIG_fail;
42694 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42695 0 : if (!SWIG_IsOK(res1)) {
42696 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_code_set" "', argument " "1"" of type '" "struct errorObj *""'");
42697 : }
42698 0 : arg1 = (struct errorObj *)(argp1);
42699 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42700 0 : if (!SWIG_IsOK(ecode2)) {
42701 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_code_set" "', argument " "2"" of type '" "int""'");
42702 : }
42703 : arg2 = (int)(val2);
42704 0 : if (arg1) (arg1)->code = arg2;
42705 : resultobj = SWIG_Py_Void();
42706 0 : return resultobj;
42707 0 : fail:
42708 : return NULL;
42709 : }
42710 :
42711 :
42712 0 : SWIGINTERN PyObject *_wrap_errorObj_code_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42713 : PyObject *resultobj = 0;
42714 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42715 0 : void *argp1 = 0 ;
42716 : int res1 = 0 ;
42717 0 : PyObject * obj0 = 0 ;
42718 : int result;
42719 :
42720 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_code_get",&obj0)) SWIG_fail;
42721 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42722 0 : if (!SWIG_IsOK(res1)) {
42723 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_code_get" "', argument " "1"" of type '" "struct errorObj *""'");
42724 : }
42725 0 : arg1 = (struct errorObj *)(argp1);
42726 0 : result = (int) ((arg1)->code);
42727 : resultobj = SWIG_From_int((int)(result));
42728 0 : return resultobj;
42729 0 : fail:
42730 : return NULL;
42731 : }
42732 :
42733 :
42734 0 : SWIGINTERN PyObject *_wrap_errorObj_routine_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42735 : PyObject *resultobj = 0;
42736 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42737 : char *arg2 ;
42738 0 : void *argp1 = 0 ;
42739 : int res1 = 0 ;
42740 : char temp2[64] ;
42741 : int res2 ;
42742 0 : PyObject * obj0 = 0 ;
42743 0 : PyObject * obj1 = 0 ;
42744 :
42745 0 : if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_routine_set",&obj0,&obj1)) SWIG_fail;
42746 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42747 0 : if (!SWIG_IsOK(res1)) {
42748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_routine_set" "', argument " "1"" of type '" "struct errorObj *""'");
42749 : }
42750 0 : arg1 = (struct errorObj *)(argp1);
42751 0 : res2 = SWIG_AsCharArray(obj1, temp2, 64);
42752 0 : if (!SWIG_IsOK(res2)) {
42753 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "errorObj_routine_set" "', argument " "2"" of type '" "char [64]""'");
42754 : }
42755 : arg2 = (char *)(temp2);
42756 0 : if (arg2) memcpy(arg1->routine,arg2,64*sizeof(char));
42757 : else memset(arg1->routine,0,64*sizeof(char));
42758 : resultobj = SWIG_Py_Void();
42759 0 : return resultobj;
42760 0 : fail:
42761 : return NULL;
42762 : }
42763 :
42764 :
42765 0 : SWIGINTERN PyObject *_wrap_errorObj_routine_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42766 : PyObject *resultobj = 0;
42767 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42768 0 : void *argp1 = 0 ;
42769 : int res1 = 0 ;
42770 0 : PyObject * obj0 = 0 ;
42771 : char *result = 0 ;
42772 :
42773 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_routine_get",&obj0)) SWIG_fail;
42774 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42775 0 : if (!SWIG_IsOK(res1)) {
42776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_routine_get" "', argument " "1"" of type '" "struct errorObj *""'");
42777 : }
42778 0 : arg1 = (struct errorObj *)(argp1);
42779 0 : result = (char *)(char *) ((arg1)->routine);
42780 : {
42781 : size_t size = SWIG_strnlen(result, 64);
42782 :
42783 :
42784 :
42785 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
42786 : }
42787 0 : return resultobj;
42788 0 : fail:
42789 : return NULL;
42790 : }
42791 :
42792 :
42793 0 : SWIGINTERN PyObject *_wrap_errorObj_message_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42794 : PyObject *resultobj = 0;
42795 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42796 : char *arg2 ;
42797 0 : void *argp1 = 0 ;
42798 : int res1 = 0 ;
42799 : char temp2[2048] ;
42800 : int res2 ;
42801 0 : PyObject * obj0 = 0 ;
42802 0 : PyObject * obj1 = 0 ;
42803 :
42804 0 : if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_message_set",&obj0,&obj1)) SWIG_fail;
42805 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42806 0 : if (!SWIG_IsOK(res1)) {
42807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_message_set" "', argument " "1"" of type '" "struct errorObj *""'");
42808 : }
42809 0 : arg1 = (struct errorObj *)(argp1);
42810 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2048);
42811 0 : if (!SWIG_IsOK(res2)) {
42812 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "errorObj_message_set" "', argument " "2"" of type '" "char [2048]""'");
42813 : }
42814 : arg2 = (char *)(temp2);
42815 0 : if (arg2) memcpy(arg1->message,arg2,2048*sizeof(char));
42816 : else memset(arg1->message,0,2048*sizeof(char));
42817 : resultobj = SWIG_Py_Void();
42818 0 : return resultobj;
42819 0 : fail:
42820 : return NULL;
42821 : }
42822 :
42823 :
42824 0 : SWIGINTERN PyObject *_wrap_errorObj_message_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42825 : PyObject *resultobj = 0;
42826 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42827 0 : void *argp1 = 0 ;
42828 : int res1 = 0 ;
42829 0 : PyObject * obj0 = 0 ;
42830 : char *result = 0 ;
42831 :
42832 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_message_get",&obj0)) SWIG_fail;
42833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42834 0 : if (!SWIG_IsOK(res1)) {
42835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_message_get" "', argument " "1"" of type '" "struct errorObj *""'");
42836 : }
42837 0 : arg1 = (struct errorObj *)(argp1);
42838 0 : result = (char *)(char *) ((arg1)->message);
42839 : {
42840 : size_t size = SWIG_strnlen(result, 2048);
42841 :
42842 :
42843 :
42844 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
42845 : }
42846 0 : return resultobj;
42847 0 : fail:
42848 : return NULL;
42849 : }
42850 :
42851 :
42852 0 : SWIGINTERN PyObject *_wrap_errorObj_isreported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42853 : PyObject *resultobj = 0;
42854 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42855 : int arg2 ;
42856 0 : void *argp1 = 0 ;
42857 : int res1 = 0 ;
42858 : int val2 ;
42859 : int ecode2 = 0 ;
42860 0 : PyObject * obj0 = 0 ;
42861 0 : PyObject * obj1 = 0 ;
42862 :
42863 0 : if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_isreported_set",&obj0,&obj1)) SWIG_fail;
42864 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42865 0 : if (!SWIG_IsOK(res1)) {
42866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_isreported_set" "', argument " "1"" of type '" "struct errorObj *""'");
42867 : }
42868 0 : arg1 = (struct errorObj *)(argp1);
42869 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42870 0 : if (!SWIG_IsOK(ecode2)) {
42871 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_isreported_set" "', argument " "2"" of type '" "int""'");
42872 : }
42873 : arg2 = (int)(val2);
42874 0 : if (arg1) (arg1)->isreported = arg2;
42875 : resultobj = SWIG_Py_Void();
42876 0 : return resultobj;
42877 0 : fail:
42878 : return NULL;
42879 : }
42880 :
42881 :
42882 0 : SWIGINTERN PyObject *_wrap_errorObj_isreported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42883 : PyObject *resultobj = 0;
42884 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42885 0 : void *argp1 = 0 ;
42886 : int res1 = 0 ;
42887 0 : PyObject * obj0 = 0 ;
42888 : int result;
42889 :
42890 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_isreported_get",&obj0)) SWIG_fail;
42891 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42892 0 : if (!SWIG_IsOK(res1)) {
42893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_isreported_get" "', argument " "1"" of type '" "struct errorObj *""'");
42894 : }
42895 0 : arg1 = (struct errorObj *)(argp1);
42896 0 : result = (int) ((arg1)->isreported);
42897 : resultobj = SWIG_From_int((int)(result));
42898 0 : return resultobj;
42899 0 : fail:
42900 : return NULL;
42901 : }
42902 :
42903 :
42904 0 : SWIGINTERN PyObject *_wrap_errorObj_errorcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42905 : PyObject *resultobj = 0;
42906 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42907 : int arg2 ;
42908 0 : void *argp1 = 0 ;
42909 : int res1 = 0 ;
42910 : int val2 ;
42911 : int ecode2 = 0 ;
42912 0 : PyObject * obj0 = 0 ;
42913 0 : PyObject * obj1 = 0 ;
42914 :
42915 0 : if (!PyArg_ParseTuple(args,(char *)"OO:errorObj_errorcount_set",&obj0,&obj1)) SWIG_fail;
42916 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42917 0 : if (!SWIG_IsOK(res1)) {
42918 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_errorcount_set" "', argument " "1"" of type '" "struct errorObj *""'");
42919 : }
42920 0 : arg1 = (struct errorObj *)(argp1);
42921 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
42922 0 : if (!SWIG_IsOK(ecode2)) {
42923 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "errorObj_errorcount_set" "', argument " "2"" of type '" "int""'");
42924 : }
42925 : arg2 = (int)(val2);
42926 0 : if (arg1) (arg1)->errorcount = arg2;
42927 : resultobj = SWIG_Py_Void();
42928 0 : return resultobj;
42929 0 : fail:
42930 : return NULL;
42931 : }
42932 :
42933 :
42934 0 : SWIGINTERN PyObject *_wrap_errorObj_errorcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42935 : PyObject *resultobj = 0;
42936 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42937 0 : void *argp1 = 0 ;
42938 : int res1 = 0 ;
42939 0 : PyObject * obj0 = 0 ;
42940 : int result;
42941 :
42942 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_errorcount_get",&obj0)) SWIG_fail;
42943 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
42944 0 : if (!SWIG_IsOK(res1)) {
42945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_errorcount_get" "', argument " "1"" of type '" "struct errorObj *""'");
42946 : }
42947 0 : arg1 = (struct errorObj *)(argp1);
42948 0 : result = (int) ((arg1)->errorcount);
42949 : resultobj = SWIG_From_int((int)(result));
42950 0 : return resultobj;
42951 0 : fail:
42952 : return NULL;
42953 : }
42954 :
42955 :
42956 0 : SWIGINTERN PyObject *_wrap_new_errorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42957 : PyObject *resultobj = 0;
42958 : struct errorObj *result = 0 ;
42959 :
42960 0 : if (!PyArg_ParseTuple(args,(char *)":new_errorObj")) SWIG_fail;
42961 : {
42962 : result = (struct errorObj *)new_errorObj(); {
42963 0 : errorObj *ms_error = msGetErrorObj();
42964 :
42965 0 : switch(ms_error->code) {
42966 : case MS_NOERR:
42967 : break;
42968 0 : case MS_NOTFOUND:
42969 0 : msResetErrorList();
42970 0 : break;
42971 : case -1:
42972 : break;
42973 0 : case MS_IOERR:
42974 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
42975 0 : _raise_ms_exception();
42976 0 : msResetErrorList();
42977 0 : return NULL;
42978 : }
42979 : default:
42980 0 : _raise_ms_exception();
42981 0 : msResetErrorList();
42982 0 : return NULL;
42983 : }
42984 :
42985 : }
42986 : }
42987 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, SWIG_POINTER_NEW | 0 );
42988 0 : return resultobj;
42989 0 : fail:
42990 : return NULL;
42991 : }
42992 :
42993 :
42994 0 : SWIGINTERN PyObject *_wrap_delete_errorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42995 : PyObject *resultobj = 0;
42996 : struct errorObj *arg1 = (struct errorObj *) 0 ;
42997 0 : void *argp1 = 0 ;
42998 : int res1 = 0 ;
42999 0 : PyObject * obj0 = 0 ;
43000 :
43001 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_errorObj",&obj0)) SWIG_fail;
43002 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, SWIG_POINTER_DISOWN | 0 );
43003 0 : if (!SWIG_IsOK(res1)) {
43004 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_errorObj" "', argument " "1"" of type '" "struct errorObj *""'");
43005 : }
43006 : arg1 = (struct errorObj *)(argp1);
43007 : {
43008 : delete_errorObj(arg1); {
43009 0 : errorObj *ms_error = msGetErrorObj();
43010 :
43011 0 : switch(ms_error->code) {
43012 : case MS_NOERR:
43013 : break;
43014 0 : case MS_NOTFOUND:
43015 0 : msResetErrorList();
43016 0 : break;
43017 : case -1:
43018 : break;
43019 0 : case MS_IOERR:
43020 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43021 0 : _raise_ms_exception();
43022 0 : msResetErrorList();
43023 0 : return NULL;
43024 : }
43025 : default:
43026 0 : _raise_ms_exception();
43027 0 : msResetErrorList();
43028 0 : return NULL;
43029 : }
43030 :
43031 : }
43032 : }
43033 : resultobj = SWIG_Py_Void();
43034 0 : return resultobj;
43035 0 : fail:
43036 : return NULL;
43037 : }
43038 :
43039 :
43040 0 : SWIGINTERN PyObject *_wrap_errorObj_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43041 : PyObject *resultobj = 0;
43042 : struct errorObj *arg1 = (struct errorObj *) 0 ;
43043 0 : void *argp1 = 0 ;
43044 : int res1 = 0 ;
43045 0 : PyObject * obj0 = 0 ;
43046 : errorObj *result = 0 ;
43047 :
43048 0 : if (!PyArg_ParseTuple(args,(char *)"O:errorObj_next",&obj0)) SWIG_fail;
43049 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_errorObj, 0 | 0 );
43050 0 : if (!SWIG_IsOK(res1)) {
43051 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "errorObj_next" "', argument " "1"" of type '" "struct errorObj *""'");
43052 : }
43053 0 : arg1 = (struct errorObj *)(argp1);
43054 : {
43055 0 : result = (errorObj *)errorObj_next(arg1); {
43056 0 : errorObj *ms_error = msGetErrorObj();
43057 :
43058 0 : switch(ms_error->code) {
43059 : case MS_NOERR:
43060 : break;
43061 0 : case MS_NOTFOUND:
43062 0 : msResetErrorList();
43063 0 : break;
43064 : case -1:
43065 : break;
43066 0 : case MS_IOERR:
43067 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43068 0 : _raise_ms_exception();
43069 0 : msResetErrorList();
43070 0 : return NULL;
43071 : }
43072 : default:
43073 0 : _raise_ms_exception();
43074 0 : msResetErrorList();
43075 0 : return NULL;
43076 : }
43077 :
43078 : }
43079 : }
43080 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, 0 | 0 );
43081 0 : return resultobj;
43082 0 : fail:
43083 : return NULL;
43084 : }
43085 :
43086 :
43087 1 : SWIGINTERN PyObject *errorObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43088 : PyObject *obj;
43089 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
43090 1 : SWIG_TypeNewClientData(SWIGTYPE_p_errorObj, SWIG_NewClientData(obj));
43091 1 : return SWIG_Py_Void();
43092 : }
43093 :
43094 0 : SWIGINTERN PyObject *_wrap_msGetErrorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43095 : PyObject *resultobj = 0;
43096 : errorObj *result = 0 ;
43097 :
43098 0 : if (!PyArg_ParseTuple(args,(char *)":msGetErrorObj")) SWIG_fail;
43099 : {
43100 0 : result = (errorObj *)msGetErrorObj(); {
43101 0 : errorObj *ms_error = msGetErrorObj();
43102 :
43103 0 : switch(ms_error->code) {
43104 : case MS_NOERR:
43105 : break;
43106 0 : case MS_NOTFOUND:
43107 0 : msResetErrorList();
43108 0 : break;
43109 : case -1:
43110 : break;
43111 0 : case MS_IOERR:
43112 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43113 0 : _raise_ms_exception();
43114 0 : msResetErrorList();
43115 0 : return NULL;
43116 : }
43117 : default:
43118 0 : _raise_ms_exception();
43119 0 : msResetErrorList();
43120 0 : return NULL;
43121 : }
43122 :
43123 : }
43124 : }
43125 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_errorObj, 0 | 0 );
43126 0 : return resultobj;
43127 0 : fail:
43128 : return NULL;
43129 : }
43130 :
43131 :
43132 0 : SWIGINTERN PyObject *_wrap_msResetErrorList(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43133 : PyObject *resultobj = 0;
43134 :
43135 0 : if (!PyArg_ParseTuple(args,(char *)":msResetErrorList")) SWIG_fail;
43136 : {
43137 0 : msResetErrorList(); {
43138 0 : errorObj *ms_error = msGetErrorObj();
43139 :
43140 0 : switch(ms_error->code) {
43141 : case MS_NOERR:
43142 : break;
43143 0 : case MS_NOTFOUND:
43144 0 : msResetErrorList();
43145 0 : break;
43146 : case -1:
43147 : break;
43148 0 : case MS_IOERR:
43149 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43150 0 : _raise_ms_exception();
43151 0 : msResetErrorList();
43152 0 : return NULL;
43153 : }
43154 : default:
43155 0 : _raise_ms_exception();
43156 0 : msResetErrorList();
43157 0 : return NULL;
43158 : }
43159 :
43160 : }
43161 : }
43162 : resultobj = SWIG_Py_Void();
43163 0 : return resultobj;
43164 0 : fail:
43165 : return NULL;
43166 : }
43167 :
43168 :
43169 1 : SWIGINTERN PyObject *_wrap_msGetVersion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43170 : PyObject *resultobj = 0;
43171 : char *result = 0 ;
43172 :
43173 1 : if (!PyArg_ParseTuple(args,(char *)":msGetVersion")) SWIG_fail;
43174 : {
43175 1 : result = (char *)msGetVersion(); {
43176 1 : errorObj *ms_error = msGetErrorObj();
43177 :
43178 1 : switch(ms_error->code) {
43179 : case MS_NOERR:
43180 : break;
43181 0 : case MS_NOTFOUND:
43182 0 : msResetErrorList();
43183 0 : break;
43184 : case -1:
43185 : break;
43186 0 : case MS_IOERR:
43187 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43188 0 : _raise_ms_exception();
43189 0 : msResetErrorList();
43190 0 : return NULL;
43191 : }
43192 : default:
43193 0 : _raise_ms_exception();
43194 0 : msResetErrorList();
43195 0 : return NULL;
43196 : }
43197 :
43198 : }
43199 : }
43200 1 : resultobj = SWIG_FromCharPtr((const char *)result);
43201 1 : return resultobj;
43202 1 : fail:
43203 : return NULL;
43204 : }
43205 :
43206 :
43207 0 : SWIGINTERN PyObject *_wrap_msGetVersionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43208 : PyObject *resultobj = 0;
43209 : int result;
43210 :
43211 0 : if (!PyArg_ParseTuple(args,(char *)":msGetVersionInt")) SWIG_fail;
43212 : {
43213 0 : result = (int)msGetVersionInt(); {
43214 0 : errorObj *ms_error = msGetErrorObj();
43215 :
43216 0 : switch(ms_error->code) {
43217 : case MS_NOERR:
43218 : break;
43219 0 : case MS_NOTFOUND:
43220 0 : msResetErrorList();
43221 0 : break;
43222 : case -1:
43223 : break;
43224 0 : case MS_IOERR:
43225 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43226 0 : _raise_ms_exception();
43227 0 : msResetErrorList();
43228 0 : return NULL;
43229 : }
43230 : default:
43231 0 : _raise_ms_exception();
43232 0 : msResetErrorList();
43233 0 : return NULL;
43234 : }
43235 :
43236 : }
43237 : }
43238 : resultobj = SWIG_From_int((int)(result));
43239 0 : return resultobj;
43240 0 : fail:
43241 : return NULL;
43242 : }
43243 :
43244 :
43245 0 : SWIGINTERN PyObject *_wrap_msGetErrorString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43246 : PyObject *resultobj = 0;
43247 : char *arg1 = (char *) 0 ;
43248 : int res1 ;
43249 0 : char *buf1 = 0 ;
43250 0 : int alloc1 = 0 ;
43251 0 : PyObject * obj0 = 0 ;
43252 : char *result = 0 ;
43253 :
43254 0 : if (!PyArg_ParseTuple(args,(char *)"O:msGetErrorString",&obj0)) SWIG_fail;
43255 0 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
43256 0 : if (!SWIG_IsOK(res1)) {
43257 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "msGetErrorString" "', argument " "1"" of type '" "char const *""'");
43258 : }
43259 0 : arg1 = (char *)(buf1);
43260 : {
43261 0 : result = (char *)msGetErrorString((char const *)arg1); {
43262 0 : errorObj *ms_error = msGetErrorObj();
43263 :
43264 0 : switch(ms_error->code) {
43265 : case MS_NOERR:
43266 : break;
43267 0 : case MS_NOTFOUND:
43268 0 : msResetErrorList();
43269 0 : break;
43270 : case -1:
43271 : break;
43272 0 : case MS_IOERR:
43273 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43274 0 : _raise_ms_exception();
43275 0 : msResetErrorList();
43276 0 : return NULL;
43277 : }
43278 : default:
43279 0 : _raise_ms_exception();
43280 0 : msResetErrorList();
43281 0 : return NULL;
43282 : }
43283 :
43284 : }
43285 : }
43286 0 : resultobj = SWIG_FromCharPtr((const char *)result);
43287 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
43288 : return resultobj;
43289 0 : fail:
43290 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
43291 : return NULL;
43292 : }
43293 :
43294 :
43295 1 : SWIGINTERN PyObject *_wrap_DBFInfo_nRecords_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43296 : PyObject *resultobj = 0;
43297 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43298 1 : void *argp1 = 0 ;
43299 : int res1 = 0 ;
43300 1 : PyObject * obj0 = 0 ;
43301 : int result;
43302 :
43303 1 : if (!PyArg_ParseTuple(args,(char *)"O:DBFInfo_nRecords_get",&obj0)) SWIG_fail;
43304 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43305 1 : if (!SWIG_IsOK(res1)) {
43306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_nRecords_get" "', argument " "1"" of type '" "DBFInfo *""'");
43307 : }
43308 1 : arg1 = (DBFInfo *)(argp1);
43309 1 : result = (int) ((arg1)->nRecords);
43310 : resultobj = SWIG_From_int((int)(result));
43311 1 : return resultobj;
43312 0 : fail:
43313 : return NULL;
43314 : }
43315 :
43316 :
43317 1 : SWIGINTERN PyObject *_wrap_DBFInfo_nFields_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43318 : PyObject *resultobj = 0;
43319 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43320 1 : void *argp1 = 0 ;
43321 : int res1 = 0 ;
43322 1 : PyObject * obj0 = 0 ;
43323 : int result;
43324 :
43325 1 : if (!PyArg_ParseTuple(args,(char *)"O:DBFInfo_nFields_get",&obj0)) SWIG_fail;
43326 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43327 1 : if (!SWIG_IsOK(res1)) {
43328 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_nFields_get" "', argument " "1"" of type '" "DBFInfo *""'");
43329 : }
43330 1 : arg1 = (DBFInfo *)(argp1);
43331 1 : result = (int) ((arg1)->nFields);
43332 : resultobj = SWIG_From_int((int)(result));
43333 1 : return resultobj;
43334 0 : fail:
43335 : return NULL;
43336 : }
43337 :
43338 :
43339 1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43340 : PyObject *resultobj = 0;
43341 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43342 : int arg2 ;
43343 1 : void *argp1 = 0 ;
43344 : int res1 = 0 ;
43345 : int val2 ;
43346 : int ecode2 = 0 ;
43347 1 : PyObject * obj0 = 0 ;
43348 1 : PyObject * obj1 = 0 ;
43349 : char *result = 0 ;
43350 :
43351 1 : if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldName",&obj0,&obj1)) SWIG_fail;
43352 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43353 1 : if (!SWIG_IsOK(res1)) {
43354 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldName" "', argument " "1"" of type '" "DBFInfo *""'");
43355 : }
43356 1 : arg1 = (DBFInfo *)(argp1);
43357 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43358 1 : if (!SWIG_IsOK(ecode2)) {
43359 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldName" "', argument " "2"" of type '" "int""'");
43360 : }
43361 : arg2 = (int)(val2);
43362 : {
43363 : result = (char *)DBFInfo_getFieldName(arg1,arg2); {
43364 1 : errorObj *ms_error = msGetErrorObj();
43365 :
43366 1 : switch(ms_error->code) {
43367 : case MS_NOERR:
43368 : break;
43369 0 : case MS_NOTFOUND:
43370 0 : msResetErrorList();
43371 0 : break;
43372 : case -1:
43373 : break;
43374 0 : case MS_IOERR:
43375 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43376 0 : _raise_ms_exception();
43377 0 : msResetErrorList();
43378 0 : return NULL;
43379 : }
43380 : default:
43381 0 : _raise_ms_exception();
43382 0 : msResetErrorList();
43383 0 : return NULL;
43384 : }
43385 :
43386 : }
43387 : }
43388 1 : resultobj = SWIG_FromCharPtr((const char *)result);
43389 1 : return resultobj;
43390 0 : fail:
43391 : return NULL;
43392 : }
43393 :
43394 :
43395 1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 : PyObject *resultobj = 0;
43397 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43398 : int arg2 ;
43399 1 : void *argp1 = 0 ;
43400 : int res1 = 0 ;
43401 : int val2 ;
43402 : int ecode2 = 0 ;
43403 1 : PyObject * obj0 = 0 ;
43404 1 : PyObject * obj1 = 0 ;
43405 : int result;
43406 :
43407 1 : if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldWidth",&obj0,&obj1)) SWIG_fail;
43408 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43409 1 : if (!SWIG_IsOK(res1)) {
43410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldWidth" "', argument " "1"" of type '" "DBFInfo *""'");
43411 : }
43412 1 : arg1 = (DBFInfo *)(argp1);
43413 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43414 1 : if (!SWIG_IsOK(ecode2)) {
43415 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldWidth" "', argument " "2"" of type '" "int""'");
43416 : }
43417 : arg2 = (int)(val2);
43418 : {
43419 1 : result = (int)DBFInfo_getFieldWidth(arg1,arg2); {
43420 1 : errorObj *ms_error = msGetErrorObj();
43421 :
43422 1 : switch(ms_error->code) {
43423 : case MS_NOERR:
43424 : break;
43425 0 : case MS_NOTFOUND:
43426 0 : msResetErrorList();
43427 0 : break;
43428 : case -1:
43429 : break;
43430 0 : case MS_IOERR:
43431 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43432 0 : _raise_ms_exception();
43433 0 : msResetErrorList();
43434 0 : return NULL;
43435 : }
43436 : default:
43437 0 : _raise_ms_exception();
43438 0 : msResetErrorList();
43439 0 : return NULL;
43440 : }
43441 :
43442 : }
43443 : }
43444 : resultobj = SWIG_From_int((int)(result));
43445 1 : return resultobj;
43446 0 : fail:
43447 : return NULL;
43448 : }
43449 :
43450 :
43451 1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldDecimals(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43452 : PyObject *resultobj = 0;
43453 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43454 : int arg2 ;
43455 1 : void *argp1 = 0 ;
43456 : int res1 = 0 ;
43457 : int val2 ;
43458 : int ecode2 = 0 ;
43459 1 : PyObject * obj0 = 0 ;
43460 1 : PyObject * obj1 = 0 ;
43461 : int result;
43462 :
43463 1 : if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldDecimals",&obj0,&obj1)) SWIG_fail;
43464 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43465 1 : if (!SWIG_IsOK(res1)) {
43466 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldDecimals" "', argument " "1"" of type '" "DBFInfo *""'");
43467 : }
43468 1 : arg1 = (DBFInfo *)(argp1);
43469 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43470 1 : if (!SWIG_IsOK(ecode2)) {
43471 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldDecimals" "', argument " "2"" of type '" "int""'");
43472 : }
43473 : arg2 = (int)(val2);
43474 : {
43475 1 : result = (int)DBFInfo_getFieldDecimals(arg1,arg2); {
43476 1 : errorObj *ms_error = msGetErrorObj();
43477 :
43478 1 : switch(ms_error->code) {
43479 : case MS_NOERR:
43480 : break;
43481 0 : case MS_NOTFOUND:
43482 0 : msResetErrorList();
43483 0 : break;
43484 : case -1:
43485 : break;
43486 0 : case MS_IOERR:
43487 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43488 0 : _raise_ms_exception();
43489 0 : msResetErrorList();
43490 0 : return NULL;
43491 : }
43492 : default:
43493 0 : _raise_ms_exception();
43494 0 : msResetErrorList();
43495 0 : return NULL;
43496 : }
43497 :
43498 : }
43499 : }
43500 : resultobj = SWIG_From_int((int)(result));
43501 1 : return resultobj;
43502 0 : fail:
43503 : return NULL;
43504 : }
43505 :
43506 :
43507 1 : SWIGINTERN PyObject *_wrap_DBFInfo_getFieldType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43508 : PyObject *resultobj = 0;
43509 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43510 : int arg2 ;
43511 1 : void *argp1 = 0 ;
43512 : int res1 = 0 ;
43513 : int val2 ;
43514 : int ecode2 = 0 ;
43515 1 : PyObject * obj0 = 0 ;
43516 1 : PyObject * obj1 = 0 ;
43517 : int result;
43518 :
43519 1 : if (!PyArg_ParseTuple(args,(char *)"OO:DBFInfo_getFieldType",&obj0,&obj1)) SWIG_fail;
43520 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, 0 | 0 );
43521 1 : if (!SWIG_IsOK(res1)) {
43522 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DBFInfo_getFieldType" "', argument " "1"" of type '" "DBFInfo *""'");
43523 : }
43524 1 : arg1 = (DBFInfo *)(argp1);
43525 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43526 1 : if (!SWIG_IsOK(ecode2)) {
43527 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "DBFInfo_getFieldType" "', argument " "2"" of type '" "int""'");
43528 : }
43529 : arg2 = (int)(val2);
43530 : {
43531 : result = (int)DBFInfo_getFieldType(arg1,arg2); {
43532 1 : errorObj *ms_error = msGetErrorObj();
43533 :
43534 1 : switch(ms_error->code) {
43535 : case MS_NOERR:
43536 : break;
43537 0 : case MS_NOTFOUND:
43538 0 : msResetErrorList();
43539 0 : break;
43540 : case -1:
43541 : break;
43542 0 : case MS_IOERR:
43543 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43544 0 : _raise_ms_exception();
43545 0 : msResetErrorList();
43546 0 : return NULL;
43547 : }
43548 : default:
43549 0 : _raise_ms_exception();
43550 0 : msResetErrorList();
43551 0 : return NULL;
43552 : }
43553 :
43554 : }
43555 : }
43556 : resultobj = SWIG_From_int((int)(result));
43557 1 : return resultobj;
43558 0 : fail:
43559 : return NULL;
43560 : }
43561 :
43562 :
43563 0 : SWIGINTERN PyObject *_wrap_new_DBFInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43564 : PyObject *resultobj = 0;
43565 : DBFInfo *result = 0 ;
43566 :
43567 0 : if (!PyArg_ParseTuple(args,(char *)":new_DBFInfo")) SWIG_fail;
43568 : {
43569 0 : result = (DBFInfo *)calloc(1, sizeof(DBFInfo)); {
43570 0 : errorObj *ms_error = msGetErrorObj();
43571 :
43572 0 : switch(ms_error->code) {
43573 : case MS_NOERR:
43574 : break;
43575 0 : case MS_NOTFOUND:
43576 0 : msResetErrorList();
43577 0 : break;
43578 : case -1:
43579 : break;
43580 0 : case MS_IOERR:
43581 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43582 0 : _raise_ms_exception();
43583 0 : msResetErrorList();
43584 0 : return NULL;
43585 : }
43586 : default:
43587 0 : _raise_ms_exception();
43588 0 : msResetErrorList();
43589 0 : return NULL;
43590 : }
43591 :
43592 : }
43593 : }
43594 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DBFInfo, SWIG_POINTER_NEW | 0 );
43595 0 : return resultobj;
43596 0 : fail:
43597 : return NULL;
43598 : }
43599 :
43600 :
43601 0 : SWIGINTERN PyObject *_wrap_delete_DBFInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43602 : PyObject *resultobj = 0;
43603 : DBFInfo *arg1 = (DBFInfo *) 0 ;
43604 0 : void *argp1 = 0 ;
43605 : int res1 = 0 ;
43606 0 : PyObject * obj0 = 0 ;
43607 :
43608 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_DBFInfo",&obj0)) SWIG_fail;
43609 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_DBFInfo, SWIG_POINTER_DISOWN | 0 );
43610 0 : if (!SWIG_IsOK(res1)) {
43611 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_DBFInfo" "', argument " "1"" of type '" "DBFInfo *""'");
43612 : }
43613 0 : arg1 = (DBFInfo *)(argp1);
43614 : {
43615 0 : free((char *) arg1); {
43616 0 : errorObj *ms_error = msGetErrorObj();
43617 :
43618 0 : switch(ms_error->code) {
43619 : case MS_NOERR:
43620 : break;
43621 0 : case MS_NOTFOUND:
43622 0 : msResetErrorList();
43623 0 : break;
43624 : case -1:
43625 : break;
43626 0 : case MS_IOERR:
43627 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43628 0 : _raise_ms_exception();
43629 0 : msResetErrorList();
43630 0 : return NULL;
43631 : }
43632 : default:
43633 0 : _raise_ms_exception();
43634 0 : msResetErrorList();
43635 0 : return NULL;
43636 : }
43637 :
43638 : }
43639 : }
43640 : resultobj = SWIG_Py_Void();
43641 0 : return resultobj;
43642 0 : fail:
43643 : return NULL;
43644 : }
43645 :
43646 :
43647 1 : SWIGINTERN PyObject *DBFInfo_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43648 : PyObject *obj;
43649 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
43650 1 : SWIG_TypeNewClientData(SWIGTYPE_p_DBFInfo, SWIG_NewClientData(obj));
43651 1 : return SWIG_Py_Void();
43652 : }
43653 :
43654 1 : SWIGINTERN PyObject *_wrap_shapefileObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43655 : PyObject *resultobj = 0;
43656 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43657 1 : void *argp1 = 0 ;
43658 : int res1 = 0 ;
43659 1 : PyObject * obj0 = 0 ;
43660 : int result;
43661 :
43662 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_type_get",&obj0)) SWIG_fail;
43663 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43664 1 : if (!SWIG_IsOK(res1)) {
43665 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_type_get" "', argument " "1"" of type '" "shapefileObj *""'");
43666 : }
43667 1 : arg1 = (shapefileObj *)(argp1);
43668 1 : result = (int) ((arg1)->type);
43669 : resultobj = SWIG_From_int((int)(result));
43670 1 : return resultobj;
43671 0 : fail:
43672 : return NULL;
43673 : }
43674 :
43675 :
43676 1 : SWIGINTERN PyObject *_wrap_shapefileObj_numshapes_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43677 : PyObject *resultobj = 0;
43678 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43679 1 : void *argp1 = 0 ;
43680 : int res1 = 0 ;
43681 1 : PyObject * obj0 = 0 ;
43682 : int result;
43683 :
43684 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_numshapes_get",&obj0)) SWIG_fail;
43685 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43686 1 : if (!SWIG_IsOK(res1)) {
43687 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_numshapes_get" "', argument " "1"" of type '" "shapefileObj *""'");
43688 : }
43689 1 : arg1 = (shapefileObj *)(argp1);
43690 1 : result = (int) ((arg1)->numshapes);
43691 : resultobj = SWIG_From_int((int)(result));
43692 1 : return resultobj;
43693 0 : fail:
43694 : return NULL;
43695 : }
43696 :
43697 :
43698 1 : SWIGINTERN PyObject *_wrap_shapefileObj_bounds_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43699 : PyObject *resultobj = 0;
43700 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43701 1 : void *argp1 = 0 ;
43702 : int res1 = 0 ;
43703 1 : PyObject * obj0 = 0 ;
43704 : rectObj *result = 0 ;
43705 :
43706 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_bounds_get",&obj0)) SWIG_fail;
43707 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43708 1 : if (!SWIG_IsOK(res1)) {
43709 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_bounds_get" "', argument " "1"" of type '" "shapefileObj *""'");
43710 : }
43711 1 : arg1 = (shapefileObj *)(argp1);
43712 1 : result = (rectObj *)& ((arg1)->bounds);
43713 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_rectObj, 0 | 0 );
43714 1 : return resultobj;
43715 0 : fail:
43716 : return NULL;
43717 : }
43718 :
43719 :
43720 1 : SWIGINTERN PyObject *_wrap_new_shapefileObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43721 : PyObject *resultobj = 0;
43722 : char *arg1 = (char *) 0 ;
43723 : int arg2 = (int) -1 ;
43724 : int res1 ;
43725 1 : char *buf1 = 0 ;
43726 1 : int alloc1 = 0 ;
43727 : int val2 ;
43728 : int ecode2 = 0 ;
43729 1 : PyObject * obj0 = 0 ;
43730 1 : PyObject * obj1 = 0 ;
43731 : shapefileObj *result = 0 ;
43732 :
43733 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:new_shapefileObj",&obj0,&obj1)) SWIG_fail;
43734 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
43735 1 : if (!SWIG_IsOK(res1)) {
43736 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_shapefileObj" "', argument " "1"" of type '" "char *""'");
43737 : }
43738 1 : arg1 = (char *)(buf1);
43739 1 : if (obj1) {
43740 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43741 1 : if (!SWIG_IsOK(ecode2)) {
43742 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_shapefileObj" "', argument " "2"" of type '" "int""'");
43743 : }
43744 : arg2 = (int)(val2);
43745 : }
43746 : {
43747 1 : result = (shapefileObj *)new_shapefileObj(arg1,arg2); {
43748 1 : errorObj *ms_error = msGetErrorObj();
43749 :
43750 1 : switch(ms_error->code) {
43751 : case MS_NOERR:
43752 : break;
43753 0 : case MS_NOTFOUND:
43754 0 : msResetErrorList();
43755 0 : break;
43756 : case -1:
43757 : break;
43758 0 : case MS_IOERR:
43759 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43760 0 : _raise_ms_exception();
43761 0 : msResetErrorList();
43762 0 : return NULL;
43763 : }
43764 : default:
43765 0 : _raise_ms_exception();
43766 0 : msResetErrorList();
43767 0 : return NULL;
43768 : }
43769 :
43770 : }
43771 : }
43772 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapefileObj, SWIG_POINTER_NEW | 0 );
43773 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
43774 : return resultobj;
43775 0 : fail:
43776 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
43777 : return NULL;
43778 : }
43779 :
43780 :
43781 1 : SWIGINTERN PyObject *_wrap_delete_shapefileObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43782 : PyObject *resultobj = 0;
43783 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43784 1 : void *argp1 = 0 ;
43785 : int res1 = 0 ;
43786 1 : PyObject * obj0 = 0 ;
43787 :
43788 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_shapefileObj",&obj0)) SWIG_fail;
43789 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, SWIG_POINTER_DISOWN | 0 );
43790 1 : if (!SWIG_IsOK(res1)) {
43791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_shapefileObj" "', argument " "1"" of type '" "shapefileObj *""'");
43792 : }
43793 1 : arg1 = (shapefileObj *)(argp1);
43794 : {
43795 : delete_shapefileObj(arg1); {
43796 1 : errorObj *ms_error = msGetErrorObj();
43797 :
43798 1 : switch(ms_error->code) {
43799 : case MS_NOERR:
43800 : break;
43801 0 : case MS_NOTFOUND:
43802 0 : msResetErrorList();
43803 0 : break;
43804 : case -1:
43805 : break;
43806 0 : case MS_IOERR:
43807 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43808 0 : _raise_ms_exception();
43809 0 : msResetErrorList();
43810 0 : return NULL;
43811 : }
43812 : default:
43813 0 : _raise_ms_exception();
43814 0 : msResetErrorList();
43815 0 : return NULL;
43816 : }
43817 :
43818 : }
43819 : }
43820 : resultobj = SWIG_Py_Void();
43821 1 : return resultobj;
43822 0 : fail:
43823 : return NULL;
43824 : }
43825 :
43826 :
43827 1 : SWIGINTERN PyObject *_wrap_shapefileObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43828 : PyObject *resultobj = 0;
43829 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43830 : int arg2 ;
43831 : shapeObj *arg3 = (shapeObj *) 0 ;
43832 1 : void *argp1 = 0 ;
43833 : int res1 = 0 ;
43834 : int val2 ;
43835 : int ecode2 = 0 ;
43836 1 : void *argp3 = 0 ;
43837 : int res3 = 0 ;
43838 1 : PyObject * obj0 = 0 ;
43839 1 : PyObject * obj1 = 0 ;
43840 1 : PyObject * obj2 = 0 ;
43841 : int result;
43842 :
43843 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_get",&obj0,&obj1,&obj2)) SWIG_fail;
43844 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43845 1 : if (!SWIG_IsOK(res1)) {
43846 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_get" "', argument " "1"" of type '" "shapefileObj *""'");
43847 : }
43848 1 : arg1 = (shapefileObj *)(argp1);
43849 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43850 1 : if (!SWIG_IsOK(ecode2)) {
43851 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_get" "', argument " "2"" of type '" "int""'");
43852 : }
43853 : arg2 = (int)(val2);
43854 1 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_shapeObj, 0 | 0 );
43855 1 : if (!SWIG_IsOK(res3)) {
43856 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_get" "', argument " "3"" of type '" "shapeObj *""'");
43857 : }
43858 1 : arg3 = (shapeObj *)(argp3);
43859 : {
43860 1 : result = (int)shapefileObj_get(arg1,arg2,arg3); {
43861 1 : errorObj *ms_error = msGetErrorObj();
43862 :
43863 1 : switch(ms_error->code) {
43864 : case MS_NOERR:
43865 : break;
43866 0 : case MS_NOTFOUND:
43867 0 : msResetErrorList();
43868 0 : break;
43869 : case -1:
43870 : break;
43871 0 : case MS_IOERR:
43872 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43873 0 : _raise_ms_exception();
43874 0 : msResetErrorList();
43875 0 : return NULL;
43876 : }
43877 : default:
43878 0 : _raise_ms_exception();
43879 0 : msResetErrorList();
43880 0 : return NULL;
43881 : }
43882 :
43883 : }
43884 : }
43885 : resultobj = SWIG_From_int((int)(result));
43886 1 : return resultobj;
43887 0 : fail:
43888 : return NULL;
43889 : }
43890 :
43891 :
43892 0 : SWIGINTERN PyObject *_wrap_shapefileObj_getShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43893 : PyObject *resultobj = 0;
43894 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43895 : int arg2 ;
43896 0 : void *argp1 = 0 ;
43897 : int res1 = 0 ;
43898 : int val2 ;
43899 : int ecode2 = 0 ;
43900 0 : PyObject * obj0 = 0 ;
43901 0 : PyObject * obj1 = 0 ;
43902 : shapeObj *result = 0 ;
43903 :
43904 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_getShape",&obj0,&obj1)) SWIG_fail;
43905 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43906 0 : if (!SWIG_IsOK(res1)) {
43907 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getShape" "', argument " "1"" of type '" "shapefileObj *""'");
43908 : }
43909 0 : arg1 = (shapefileObj *)(argp1);
43910 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43911 0 : if (!SWIG_IsOK(ecode2)) {
43912 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getShape" "', argument " "2"" of type '" "int""'");
43913 : }
43914 : arg2 = (int)(val2);
43915 : {
43916 0 : result = (shapeObj *)shapefileObj_getShape(arg1,arg2); {
43917 0 : errorObj *ms_error = msGetErrorObj();
43918 :
43919 0 : switch(ms_error->code) {
43920 : case MS_NOERR:
43921 : break;
43922 0 : case MS_NOTFOUND:
43923 0 : msResetErrorList();
43924 0 : break;
43925 : case -1:
43926 : break;
43927 0 : case MS_IOERR:
43928 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43929 0 : _raise_ms_exception();
43930 0 : msResetErrorList();
43931 0 : return NULL;
43932 : }
43933 : default:
43934 0 : _raise_ms_exception();
43935 0 : msResetErrorList();
43936 0 : return NULL;
43937 : }
43938 :
43939 : }
43940 : }
43941 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_shapeObj, SWIG_POINTER_OWN | 0 );
43942 0 : return resultobj;
43943 0 : fail:
43944 : return NULL;
43945 : }
43946 :
43947 :
43948 0 : SWIGINTERN PyObject *_wrap_shapefileObj_getPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43949 : PyObject *resultobj = 0;
43950 : shapefileObj *arg1 = (shapefileObj *) 0 ;
43951 : int arg2 ;
43952 : pointObj *arg3 = (pointObj *) 0 ;
43953 0 : void *argp1 = 0 ;
43954 : int res1 = 0 ;
43955 : int val2 ;
43956 : int ecode2 = 0 ;
43957 0 : void *argp3 = 0 ;
43958 : int res3 = 0 ;
43959 0 : PyObject * obj0 = 0 ;
43960 0 : PyObject * obj1 = 0 ;
43961 0 : PyObject * obj2 = 0 ;
43962 : int result;
43963 :
43964 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_getPoint",&obj0,&obj1,&obj2)) SWIG_fail;
43965 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
43966 0 : if (!SWIG_IsOK(res1)) {
43967 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getPoint" "', argument " "1"" of type '" "shapefileObj *""'");
43968 : }
43969 0 : arg1 = (shapefileObj *)(argp1);
43970 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
43971 0 : if (!SWIG_IsOK(ecode2)) {
43972 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getPoint" "', argument " "2"" of type '" "int""'");
43973 : }
43974 : arg2 = (int)(val2);
43975 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_pointObj, 0 | 0 );
43976 0 : if (!SWIG_IsOK(res3)) {
43977 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_getPoint" "', argument " "3"" of type '" "pointObj *""'");
43978 : }
43979 0 : arg3 = (pointObj *)(argp3);
43980 : {
43981 : result = (int)shapefileObj_getPoint(arg1,arg2,arg3); {
43982 0 : errorObj *ms_error = msGetErrorObj();
43983 :
43984 0 : switch(ms_error->code) {
43985 : case MS_NOERR:
43986 : break;
43987 0 : case MS_NOTFOUND:
43988 0 : msResetErrorList();
43989 0 : break;
43990 : case -1:
43991 : break;
43992 0 : case MS_IOERR:
43993 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
43994 0 : _raise_ms_exception();
43995 0 : msResetErrorList();
43996 0 : return NULL;
43997 : }
43998 : default:
43999 0 : _raise_ms_exception();
44000 0 : msResetErrorList();
44001 0 : return NULL;
44002 : }
44003 :
44004 : }
44005 : }
44006 : resultobj = SWIG_From_int((int)(result));
44007 0 : return resultobj;
44008 0 : fail:
44009 : return NULL;
44010 : }
44011 :
44012 :
44013 0 : SWIGINTERN PyObject *_wrap_shapefileObj_getTransformed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44014 : PyObject *resultobj = 0;
44015 : shapefileObj *arg1 = (shapefileObj *) 0 ;
44016 : mapObj *arg2 = (mapObj *) 0 ;
44017 : int arg3 ;
44018 : shapeObj *arg4 = (shapeObj *) 0 ;
44019 0 : void *argp1 = 0 ;
44020 : int res1 = 0 ;
44021 0 : void *argp2 = 0 ;
44022 : int res2 = 0 ;
44023 : int val3 ;
44024 : int ecode3 = 0 ;
44025 0 : void *argp4 = 0 ;
44026 : int res4 = 0 ;
44027 0 : PyObject * obj0 = 0 ;
44028 0 : PyObject * obj1 = 0 ;
44029 0 : PyObject * obj2 = 0 ;
44030 0 : PyObject * obj3 = 0 ;
44031 : int result;
44032 :
44033 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:shapefileObj_getTransformed",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44034 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
44035 0 : if (!SWIG_IsOK(res1)) {
44036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getTransformed" "', argument " "1"" of type '" "shapefileObj *""'");
44037 : }
44038 0 : arg1 = (shapefileObj *)(argp1);
44039 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_mapObj, 0 | 0 );
44040 0 : if (!SWIG_IsOK(res2)) {
44041 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_getTransformed" "', argument " "2"" of type '" "mapObj *""'");
44042 : }
44043 0 : arg2 = (mapObj *)(argp2);
44044 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
44045 0 : if (!SWIG_IsOK(ecode3)) {
44046 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "shapefileObj_getTransformed" "', argument " "3"" of type '" "int""'");
44047 : }
44048 : arg3 = (int)(val3);
44049 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_shapeObj, 0 | 0 );
44050 0 : if (!SWIG_IsOK(res4)) {
44051 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "shapefileObj_getTransformed" "', argument " "4"" of type '" "shapeObj *""'");
44052 : }
44053 0 : arg4 = (shapeObj *)(argp4);
44054 : {
44055 0 : result = (int)shapefileObj_getTransformed(arg1,arg2,arg3,arg4); {
44056 0 : errorObj *ms_error = msGetErrorObj();
44057 :
44058 0 : switch(ms_error->code) {
44059 : case MS_NOERR:
44060 : break;
44061 0 : case MS_NOTFOUND:
44062 0 : msResetErrorList();
44063 0 : break;
44064 : case -1:
44065 : break;
44066 0 : case MS_IOERR:
44067 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44068 0 : _raise_ms_exception();
44069 0 : msResetErrorList();
44070 0 : return NULL;
44071 : }
44072 : default:
44073 0 : _raise_ms_exception();
44074 0 : msResetErrorList();
44075 0 : return NULL;
44076 : }
44077 :
44078 : }
44079 : }
44080 : resultobj = SWIG_From_int((int)(result));
44081 0 : return resultobj;
44082 0 : fail:
44083 : return NULL;
44084 : }
44085 :
44086 :
44087 0 : SWIGINTERN PyObject *_wrap_shapefileObj_getExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44088 : PyObject *resultobj = 0;
44089 : shapefileObj *arg1 = (shapefileObj *) 0 ;
44090 : int arg2 ;
44091 : rectObj *arg3 = (rectObj *) 0 ;
44092 0 : void *argp1 = 0 ;
44093 : int res1 = 0 ;
44094 : int val2 ;
44095 : int ecode2 = 0 ;
44096 0 : void *argp3 = 0 ;
44097 : int res3 = 0 ;
44098 0 : PyObject * obj0 = 0 ;
44099 0 : PyObject * obj1 = 0 ;
44100 0 : PyObject * obj2 = 0 ;
44101 :
44102 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:shapefileObj_getExtent",&obj0,&obj1,&obj2)) SWIG_fail;
44103 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
44104 0 : if (!SWIG_IsOK(res1)) {
44105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getExtent" "', argument " "1"" of type '" "shapefileObj *""'");
44106 : }
44107 0 : arg1 = (shapefileObj *)(argp1);
44108 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44109 0 : if (!SWIG_IsOK(ecode2)) {
44110 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "shapefileObj_getExtent" "', argument " "2"" of type '" "int""'");
44111 : }
44112 : arg2 = (int)(val2);
44113 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_rectObj, 0 | 0 );
44114 0 : if (!SWIG_IsOK(res3)) {
44115 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "shapefileObj_getExtent" "', argument " "3"" of type '" "rectObj *""'");
44116 : }
44117 0 : arg3 = (rectObj *)(argp3);
44118 : {
44119 0 : shapefileObj_getExtent(arg1,arg2,arg3); {
44120 0 : errorObj *ms_error = msGetErrorObj();
44121 :
44122 0 : switch(ms_error->code) {
44123 : case MS_NOERR:
44124 : break;
44125 0 : case MS_NOTFOUND:
44126 0 : msResetErrorList();
44127 0 : break;
44128 : case -1:
44129 : break;
44130 0 : case MS_IOERR:
44131 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44132 0 : _raise_ms_exception();
44133 0 : msResetErrorList();
44134 0 : return NULL;
44135 : }
44136 : default:
44137 0 : _raise_ms_exception();
44138 0 : msResetErrorList();
44139 0 : return NULL;
44140 : }
44141 :
44142 : }
44143 : }
44144 : resultobj = SWIG_Py_Void();
44145 0 : return resultobj;
44146 0 : fail:
44147 : return NULL;
44148 : }
44149 :
44150 :
44151 1 : SWIGINTERN PyObject *_wrap_shapefileObj_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44152 : PyObject *resultobj = 0;
44153 : shapefileObj *arg1 = (shapefileObj *) 0 ;
44154 : shapeObj *arg2 = (shapeObj *) 0 ;
44155 1 : void *argp1 = 0 ;
44156 : int res1 = 0 ;
44157 1 : void *argp2 = 0 ;
44158 : int res2 = 0 ;
44159 1 : PyObject * obj0 = 0 ;
44160 1 : PyObject * obj1 = 0 ;
44161 : int result;
44162 :
44163 1 : if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_add",&obj0,&obj1)) SWIG_fail;
44164 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
44165 1 : if (!SWIG_IsOK(res1)) {
44166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_add" "', argument " "1"" of type '" "shapefileObj *""'");
44167 : }
44168 1 : arg1 = (shapefileObj *)(argp1);
44169 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_shapeObj, 0 | 0 );
44170 1 : if (!SWIG_IsOK(res2)) {
44171 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_add" "', argument " "2"" of type '" "shapeObj *""'");
44172 : }
44173 1 : arg2 = (shapeObj *)(argp2);
44174 : {
44175 1 : result = (int)shapefileObj_add(arg1,arg2); {
44176 1 : errorObj *ms_error = msGetErrorObj();
44177 :
44178 1 : switch(ms_error->code) {
44179 : case MS_NOERR:
44180 : break;
44181 0 : case MS_NOTFOUND:
44182 0 : msResetErrorList();
44183 0 : break;
44184 : case -1:
44185 : break;
44186 0 : case MS_IOERR:
44187 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44188 0 : _raise_ms_exception();
44189 0 : msResetErrorList();
44190 0 : return NULL;
44191 : }
44192 : default:
44193 1 : _raise_ms_exception();
44194 1 : msResetErrorList();
44195 1 : return NULL;
44196 : }
44197 :
44198 : }
44199 : }
44200 : resultobj = SWIG_From_int((int)(result));
44201 0 : return resultobj;
44202 0 : fail:
44203 : return NULL;
44204 : }
44205 :
44206 :
44207 0 : SWIGINTERN PyObject *_wrap_shapefileObj_addPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44208 : PyObject *resultobj = 0;
44209 : shapefileObj *arg1 = (shapefileObj *) 0 ;
44210 : pointObj *arg2 = (pointObj *) 0 ;
44211 0 : void *argp1 = 0 ;
44212 : int res1 = 0 ;
44213 0 : void *argp2 = 0 ;
44214 : int res2 = 0 ;
44215 0 : PyObject * obj0 = 0 ;
44216 0 : PyObject * obj1 = 0 ;
44217 : int result;
44218 :
44219 0 : if (!PyArg_ParseTuple(args,(char *)"OO:shapefileObj_addPoint",&obj0,&obj1)) SWIG_fail;
44220 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
44221 0 : if (!SWIG_IsOK(res1)) {
44222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_addPoint" "', argument " "1"" of type '" "shapefileObj *""'");
44223 : }
44224 0 : arg1 = (shapefileObj *)(argp1);
44225 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_pointObj, 0 | 0 );
44226 0 : if (!SWIG_IsOK(res2)) {
44227 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "shapefileObj_addPoint" "', argument " "2"" of type '" "pointObj *""'");
44228 : }
44229 0 : arg2 = (pointObj *)(argp2);
44230 : {
44231 0 : result = (int)shapefileObj_addPoint(arg1,arg2); {
44232 0 : errorObj *ms_error = msGetErrorObj();
44233 :
44234 0 : switch(ms_error->code) {
44235 : case MS_NOERR:
44236 : break;
44237 0 : case MS_NOTFOUND:
44238 0 : msResetErrorList();
44239 0 : break;
44240 : case -1:
44241 : break;
44242 0 : case MS_IOERR:
44243 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44244 0 : _raise_ms_exception();
44245 0 : msResetErrorList();
44246 0 : return NULL;
44247 : }
44248 : default:
44249 0 : _raise_ms_exception();
44250 0 : msResetErrorList();
44251 0 : return NULL;
44252 : }
44253 :
44254 : }
44255 : }
44256 : resultobj = SWIG_From_int((int)(result));
44257 0 : return resultobj;
44258 0 : fail:
44259 : return NULL;
44260 : }
44261 :
44262 :
44263 1 : SWIGINTERN PyObject *_wrap_shapefileObj_getDBF(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44264 : PyObject *resultobj = 0;
44265 : shapefileObj *arg1 = (shapefileObj *) 0 ;
44266 1 : void *argp1 = 0 ;
44267 : int res1 = 0 ;
44268 1 : PyObject * obj0 = 0 ;
44269 : DBFInfo *result = 0 ;
44270 :
44271 1 : if (!PyArg_ParseTuple(args,(char *)"O:shapefileObj_getDBF",&obj0)) SWIG_fail;
44272 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_shapefileObj, 0 | 0 );
44273 1 : if (!SWIG_IsOK(res1)) {
44274 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "shapefileObj_getDBF" "', argument " "1"" of type '" "shapefileObj *""'");
44275 : }
44276 1 : arg1 = (shapefileObj *)(argp1);
44277 : {
44278 1 : result = (DBFInfo *)shapefileObj_getDBF(arg1); {
44279 1 : errorObj *ms_error = msGetErrorObj();
44280 :
44281 1 : switch(ms_error->code) {
44282 : case MS_NOERR:
44283 : break;
44284 0 : case MS_NOTFOUND:
44285 0 : msResetErrorList();
44286 0 : break;
44287 : case -1:
44288 : break;
44289 0 : case MS_IOERR:
44290 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44291 0 : _raise_ms_exception();
44292 0 : msResetErrorList();
44293 0 : return NULL;
44294 : }
44295 : default:
44296 0 : _raise_ms_exception();
44297 0 : msResetErrorList();
44298 0 : return NULL;
44299 : }
44300 :
44301 : }
44302 : }
44303 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_DBFInfo, 0 | 0 );
44304 1 : return resultobj;
44305 0 : fail:
44306 : return NULL;
44307 : }
44308 :
44309 :
44310 1 : SWIGINTERN PyObject *shapefileObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44311 : PyObject *obj;
44312 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
44313 1 : SWIG_TypeNewClientData(SWIGTYPE_p_shapefileObj, SWIG_NewClientData(obj));
44314 1 : return SWIG_Py_Void();
44315 : }
44316 :
44317 0 : SWIGINTERN PyObject *_wrap_projectionObj_numargs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44318 : PyObject *resultobj = 0;
44319 : projectionObj *arg1 = (projectionObj *) 0 ;
44320 0 : void *argp1 = 0 ;
44321 : int res1 = 0 ;
44322 0 : PyObject * obj0 = 0 ;
44323 : int result;
44324 :
44325 0 : if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_numargs_get",&obj0)) SWIG_fail;
44326 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44327 0 : if (!SWIG_IsOK(res1)) {
44328 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_numargs_get" "', argument " "1"" of type '" "projectionObj *""'");
44329 : }
44330 0 : arg1 = (projectionObj *)(argp1);
44331 0 : result = (int) ((arg1)->numargs);
44332 : resultobj = SWIG_From_int((int)(result));
44333 0 : return resultobj;
44334 0 : fail:
44335 : return NULL;
44336 : }
44337 :
44338 :
44339 0 : SWIGINTERN PyObject *_wrap_projectionObj_automatic_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44340 : PyObject *resultobj = 0;
44341 : projectionObj *arg1 = (projectionObj *) 0 ;
44342 0 : void *argp1 = 0 ;
44343 : int res1 = 0 ;
44344 0 : PyObject * obj0 = 0 ;
44345 : int result;
44346 :
44347 0 : if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_automatic_get",&obj0)) SWIG_fail;
44348 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44349 0 : if (!SWIG_IsOK(res1)) {
44350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_automatic_get" "', argument " "1"" of type '" "projectionObj *""'");
44351 : }
44352 0 : arg1 = (projectionObj *)(argp1);
44353 0 : result = (int) ((arg1)->automatic);
44354 : resultobj = SWIG_From_int((int)(result));
44355 0 : return resultobj;
44356 0 : fail:
44357 : return NULL;
44358 : }
44359 :
44360 :
44361 0 : SWIGINTERN PyObject *_wrap_projectionObj_wellknownprojection_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44362 : PyObject *resultobj = 0;
44363 : projectionObj *arg1 = (projectionObj *) 0 ;
44364 : int arg2 ;
44365 0 : void *argp1 = 0 ;
44366 : int res1 = 0 ;
44367 : int val2 ;
44368 : int ecode2 = 0 ;
44369 0 : PyObject * obj0 = 0 ;
44370 0 : PyObject * obj1 = 0 ;
44371 :
44372 0 : if (!PyArg_ParseTuple(args,(char *)"OO:projectionObj_wellknownprojection_set",&obj0,&obj1)) SWIG_fail;
44373 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44374 0 : if (!SWIG_IsOK(res1)) {
44375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_wellknownprojection_set" "', argument " "1"" of type '" "projectionObj *""'");
44376 : }
44377 0 : arg1 = (projectionObj *)(argp1);
44378 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44379 0 : if (!SWIG_IsOK(ecode2)) {
44380 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "projectionObj_wellknownprojection_set" "', argument " "2"" of type '" "int""'");
44381 : }
44382 : arg2 = (int)(val2);
44383 0 : if (arg1) (arg1)->wellknownprojection = arg2;
44384 : resultobj = SWIG_Py_Void();
44385 0 : return resultobj;
44386 0 : fail:
44387 : return NULL;
44388 : }
44389 :
44390 :
44391 0 : SWIGINTERN PyObject *_wrap_projectionObj_wellknownprojection_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44392 : PyObject *resultobj = 0;
44393 : projectionObj *arg1 = (projectionObj *) 0 ;
44394 0 : void *argp1 = 0 ;
44395 : int res1 = 0 ;
44396 0 : PyObject * obj0 = 0 ;
44397 : int result;
44398 :
44399 0 : if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_wellknownprojection_get",&obj0)) SWIG_fail;
44400 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44401 0 : if (!SWIG_IsOK(res1)) {
44402 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_wellknownprojection_get" "', argument " "1"" of type '" "projectionObj *""'");
44403 : }
44404 0 : arg1 = (projectionObj *)(argp1);
44405 0 : result = (int) ((arg1)->wellknownprojection);
44406 : resultobj = SWIG_From_int((int)(result));
44407 0 : return resultobj;
44408 0 : fail:
44409 : return NULL;
44410 : }
44411 :
44412 :
44413 1 : SWIGINTERN PyObject *_wrap_new_projectionObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44414 : PyObject *resultobj = 0;
44415 : char *arg1 = (char *) 0 ;
44416 : int res1 ;
44417 1 : char *buf1 = 0 ;
44418 1 : int alloc1 = 0 ;
44419 1 : PyObject * obj0 = 0 ;
44420 : projectionObj *result = 0 ;
44421 :
44422 1 : if (!PyArg_ParseTuple(args,(char *)"O:new_projectionObj",&obj0)) SWIG_fail;
44423 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
44424 1 : if (!SWIG_IsOK(res1)) {
44425 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_projectionObj" "', argument " "1"" of type '" "char *""'");
44426 : }
44427 1 : arg1 = (char *)(buf1);
44428 : {
44429 1 : result = (projectionObj *)new_projectionObj(arg1); {
44430 1 : errorObj *ms_error = msGetErrorObj();
44431 :
44432 1 : switch(ms_error->code) {
44433 : case MS_NOERR:
44434 : break;
44435 0 : case MS_NOTFOUND:
44436 0 : msResetErrorList();
44437 0 : break;
44438 : case -1:
44439 : break;
44440 0 : case MS_IOERR:
44441 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44442 0 : _raise_ms_exception();
44443 0 : msResetErrorList();
44444 0 : return NULL;
44445 : }
44446 : default:
44447 0 : _raise_ms_exception();
44448 0 : msResetErrorList();
44449 0 : return NULL;
44450 : }
44451 :
44452 : }
44453 : }
44454 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_projectionObj, SWIG_POINTER_NEW | 0 );
44455 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
44456 : return resultobj;
44457 0 : fail:
44458 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
44459 : return NULL;
44460 : }
44461 :
44462 :
44463 1 : SWIGINTERN PyObject *_wrap_delete_projectionObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44464 : PyObject *resultobj = 0;
44465 : projectionObj *arg1 = (projectionObj *) 0 ;
44466 1 : void *argp1 = 0 ;
44467 : int res1 = 0 ;
44468 1 : PyObject * obj0 = 0 ;
44469 :
44470 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_projectionObj",&obj0)) SWIG_fail;
44471 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, SWIG_POINTER_DISOWN | 0 );
44472 1 : if (!SWIG_IsOK(res1)) {
44473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_projectionObj" "', argument " "1"" of type '" "projectionObj *""'");
44474 : }
44475 1 : arg1 = (projectionObj *)(argp1);
44476 : {
44477 : delete_projectionObj(arg1); {
44478 1 : errorObj *ms_error = msGetErrorObj();
44479 :
44480 1 : switch(ms_error->code) {
44481 : case MS_NOERR:
44482 : break;
44483 0 : case MS_NOTFOUND:
44484 0 : msResetErrorList();
44485 0 : break;
44486 : case -1:
44487 : break;
44488 0 : case MS_IOERR:
44489 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44490 0 : _raise_ms_exception();
44491 0 : msResetErrorList();
44492 0 : return NULL;
44493 : }
44494 : default:
44495 0 : _raise_ms_exception();
44496 0 : msResetErrorList();
44497 0 : return NULL;
44498 : }
44499 :
44500 : }
44501 : }
44502 : resultobj = SWIG_Py_Void();
44503 1 : return resultobj;
44504 0 : fail:
44505 : return NULL;
44506 : }
44507 :
44508 :
44509 0 : SWIGINTERN PyObject *_wrap_projectionObj_setWKTProjection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44510 : PyObject *resultobj = 0;
44511 : projectionObj *arg1 = (projectionObj *) 0 ;
44512 : char *arg2 = (char *) 0 ;
44513 0 : void *argp1 = 0 ;
44514 : int res1 = 0 ;
44515 : int res2 ;
44516 0 : char *buf2 = 0 ;
44517 0 : int alloc2 = 0 ;
44518 0 : PyObject * obj0 = 0 ;
44519 0 : PyObject * obj1 = 0 ;
44520 : int result;
44521 :
44522 0 : if (!PyArg_ParseTuple(args,(char *)"OO:projectionObj_setWKTProjection",&obj0,&obj1)) SWIG_fail;
44523 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44524 0 : if (!SWIG_IsOK(res1)) {
44525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_setWKTProjection" "', argument " "1"" of type '" "projectionObj *""'");
44526 : }
44527 0 : arg1 = (projectionObj *)(argp1);
44528 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
44529 0 : if (!SWIG_IsOK(res2)) {
44530 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "projectionObj_setWKTProjection" "', argument " "2"" of type '" "char *""'");
44531 : }
44532 0 : arg2 = (char *)(buf2);
44533 : {
44534 : result = (int)projectionObj_setWKTProjection(arg1,arg2); {
44535 0 : errorObj *ms_error = msGetErrorObj();
44536 :
44537 0 : switch(ms_error->code) {
44538 : case MS_NOERR:
44539 : break;
44540 0 : case MS_NOTFOUND:
44541 0 : msResetErrorList();
44542 0 : break;
44543 : case -1:
44544 : break;
44545 0 : case MS_IOERR:
44546 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44547 0 : _raise_ms_exception();
44548 0 : msResetErrorList();
44549 0 : return NULL;
44550 : }
44551 : default:
44552 0 : _raise_ms_exception();
44553 0 : msResetErrorList();
44554 0 : return NULL;
44555 : }
44556 :
44557 : }
44558 : }
44559 : resultobj = SWIG_From_int((int)(result));
44560 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
44561 : return resultobj;
44562 0 : fail:
44563 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
44564 : return NULL;
44565 : }
44566 :
44567 :
44568 1 : SWIGINTERN PyObject *_wrap_projectionObj_getUnits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44569 : PyObject *resultobj = 0;
44570 : projectionObj *arg1 = (projectionObj *) 0 ;
44571 1 : void *argp1 = 0 ;
44572 : int res1 = 0 ;
44573 1 : PyObject * obj0 = 0 ;
44574 : int result;
44575 :
44576 1 : if (!PyArg_ParseTuple(args,(char *)"O:projectionObj_getUnits",&obj0)) SWIG_fail;
44577 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_projectionObj, 0 | 0 );
44578 1 : if (!SWIG_IsOK(res1)) {
44579 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "projectionObj_getUnits" "', argument " "1"" of type '" "projectionObj *""'");
44580 : }
44581 1 : arg1 = (projectionObj *)(argp1);
44582 : {
44583 : result = (int)projectionObj_getUnits(arg1); {
44584 1 : errorObj *ms_error = msGetErrorObj();
44585 :
44586 1 : switch(ms_error->code) {
44587 : case MS_NOERR:
44588 : break;
44589 0 : case MS_NOTFOUND:
44590 0 : msResetErrorList();
44591 0 : break;
44592 : case -1:
44593 : break;
44594 0 : case MS_IOERR:
44595 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44596 0 : _raise_ms_exception();
44597 0 : msResetErrorList();
44598 0 : return NULL;
44599 : }
44600 : default:
44601 0 : _raise_ms_exception();
44602 0 : msResetErrorList();
44603 0 : return NULL;
44604 : }
44605 :
44606 : }
44607 : }
44608 : resultobj = SWIG_From_int((int)(result));
44609 1 : return resultobj;
44610 0 : fail:
44611 : return NULL;
44612 : }
44613 :
44614 :
44615 1 : SWIGINTERN PyObject *projectionObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44616 : PyObject *obj;
44617 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
44618 1 : SWIG_TypeNewClientData(SWIGTYPE_p_projectionObj, SWIG_NewClientData(obj));
44619 1 : return SWIG_Py_Void();
44620 : }
44621 :
44622 0 : SWIGINTERN PyObject *_wrap_colorObj_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44623 : PyObject *resultobj = 0;
44624 : colorObj *arg1 = (colorObj *) 0 ;
44625 : int arg2 ;
44626 0 : void *argp1 = 0 ;
44627 : int res1 = 0 ;
44628 : int val2 ;
44629 : int ecode2 = 0 ;
44630 0 : PyObject * obj0 = 0 ;
44631 0 : PyObject * obj1 = 0 ;
44632 :
44633 0 : if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_red_set",&obj0,&obj1)) SWIG_fail;
44634 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44635 0 : if (!SWIG_IsOK(res1)) {
44636 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_red_set" "', argument " "1"" of type '" "colorObj *""'");
44637 : }
44638 0 : arg1 = (colorObj *)(argp1);
44639 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44640 0 : if (!SWIG_IsOK(ecode2)) {
44641 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_red_set" "', argument " "2"" of type '" "int""'");
44642 : }
44643 : arg2 = (int)(val2);
44644 0 : if (arg1) (arg1)->red = arg2;
44645 : resultobj = SWIG_Py_Void();
44646 0 : return resultobj;
44647 0 : fail:
44648 : return NULL;
44649 : }
44650 :
44651 :
44652 1 : SWIGINTERN PyObject *_wrap_colorObj_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44653 : PyObject *resultobj = 0;
44654 : colorObj *arg1 = (colorObj *) 0 ;
44655 1 : void *argp1 = 0 ;
44656 : int res1 = 0 ;
44657 1 : PyObject * obj0 = 0 ;
44658 : int result;
44659 :
44660 1 : if (!PyArg_ParseTuple(args,(char *)"O:colorObj_red_get",&obj0)) SWIG_fail;
44661 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44662 1 : if (!SWIG_IsOK(res1)) {
44663 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_red_get" "', argument " "1"" of type '" "colorObj *""'");
44664 : }
44665 1 : arg1 = (colorObj *)(argp1);
44666 1 : result = (int) ((arg1)->red);
44667 : resultobj = SWIG_From_int((int)(result));
44668 1 : return resultobj;
44669 0 : fail:
44670 : return NULL;
44671 : }
44672 :
44673 :
44674 0 : SWIGINTERN PyObject *_wrap_colorObj_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44675 : PyObject *resultobj = 0;
44676 : colorObj *arg1 = (colorObj *) 0 ;
44677 : int arg2 ;
44678 0 : void *argp1 = 0 ;
44679 : int res1 = 0 ;
44680 : int val2 ;
44681 : int ecode2 = 0 ;
44682 0 : PyObject * obj0 = 0 ;
44683 0 : PyObject * obj1 = 0 ;
44684 :
44685 0 : if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_green_set",&obj0,&obj1)) SWIG_fail;
44686 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44687 0 : if (!SWIG_IsOK(res1)) {
44688 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_green_set" "', argument " "1"" of type '" "colorObj *""'");
44689 : }
44690 0 : arg1 = (colorObj *)(argp1);
44691 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44692 0 : if (!SWIG_IsOK(ecode2)) {
44693 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_green_set" "', argument " "2"" of type '" "int""'");
44694 : }
44695 : arg2 = (int)(val2);
44696 0 : if (arg1) (arg1)->green = arg2;
44697 : resultobj = SWIG_Py_Void();
44698 0 : return resultobj;
44699 0 : fail:
44700 : return NULL;
44701 : }
44702 :
44703 :
44704 1 : SWIGINTERN PyObject *_wrap_colorObj_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44705 : PyObject *resultobj = 0;
44706 : colorObj *arg1 = (colorObj *) 0 ;
44707 1 : void *argp1 = 0 ;
44708 : int res1 = 0 ;
44709 1 : PyObject * obj0 = 0 ;
44710 : int result;
44711 :
44712 1 : if (!PyArg_ParseTuple(args,(char *)"O:colorObj_green_get",&obj0)) SWIG_fail;
44713 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44714 1 : if (!SWIG_IsOK(res1)) {
44715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_green_get" "', argument " "1"" of type '" "colorObj *""'");
44716 : }
44717 1 : arg1 = (colorObj *)(argp1);
44718 1 : result = (int) ((arg1)->green);
44719 : resultobj = SWIG_From_int((int)(result));
44720 1 : return resultobj;
44721 0 : fail:
44722 : return NULL;
44723 : }
44724 :
44725 :
44726 0 : SWIGINTERN PyObject *_wrap_colorObj_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44727 : PyObject *resultobj = 0;
44728 : colorObj *arg1 = (colorObj *) 0 ;
44729 : int arg2 ;
44730 0 : void *argp1 = 0 ;
44731 : int res1 = 0 ;
44732 : int val2 ;
44733 : int ecode2 = 0 ;
44734 0 : PyObject * obj0 = 0 ;
44735 0 : PyObject * obj1 = 0 ;
44736 :
44737 0 : if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_blue_set",&obj0,&obj1)) SWIG_fail;
44738 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44739 0 : if (!SWIG_IsOK(res1)) {
44740 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_blue_set" "', argument " "1"" of type '" "colorObj *""'");
44741 : }
44742 0 : arg1 = (colorObj *)(argp1);
44743 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44744 0 : if (!SWIG_IsOK(ecode2)) {
44745 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_blue_set" "', argument " "2"" of type '" "int""'");
44746 : }
44747 : arg2 = (int)(val2);
44748 0 : if (arg1) (arg1)->blue = arg2;
44749 : resultobj = SWIG_Py_Void();
44750 0 : return resultobj;
44751 0 : fail:
44752 : return NULL;
44753 : }
44754 :
44755 :
44756 1 : SWIGINTERN PyObject *_wrap_colorObj_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44757 : PyObject *resultobj = 0;
44758 : colorObj *arg1 = (colorObj *) 0 ;
44759 1 : void *argp1 = 0 ;
44760 : int res1 = 0 ;
44761 1 : PyObject * obj0 = 0 ;
44762 : int result;
44763 :
44764 1 : if (!PyArg_ParseTuple(args,(char *)"O:colorObj_blue_get",&obj0)) SWIG_fail;
44765 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44766 1 : if (!SWIG_IsOK(res1)) {
44767 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_blue_get" "', argument " "1"" of type '" "colorObj *""'");
44768 : }
44769 1 : arg1 = (colorObj *)(argp1);
44770 1 : result = (int) ((arg1)->blue);
44771 : resultobj = SWIG_From_int((int)(result));
44772 1 : return resultobj;
44773 0 : fail:
44774 : return NULL;
44775 : }
44776 :
44777 :
44778 0 : SWIGINTERN PyObject *_wrap_colorObj_alpha_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44779 : PyObject *resultobj = 0;
44780 : colorObj *arg1 = (colorObj *) 0 ;
44781 : int arg2 ;
44782 0 : void *argp1 = 0 ;
44783 : int res1 = 0 ;
44784 : int val2 ;
44785 : int ecode2 = 0 ;
44786 0 : PyObject * obj0 = 0 ;
44787 0 : PyObject * obj1 = 0 ;
44788 :
44789 0 : if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_alpha_set",&obj0,&obj1)) SWIG_fail;
44790 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44791 0 : if (!SWIG_IsOK(res1)) {
44792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_alpha_set" "', argument " "1"" of type '" "colorObj *""'");
44793 : }
44794 0 : arg1 = (colorObj *)(argp1);
44795 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44796 0 : if (!SWIG_IsOK(ecode2)) {
44797 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_alpha_set" "', argument " "2"" of type '" "int""'");
44798 : }
44799 : arg2 = (int)(val2);
44800 0 : if (arg1) (arg1)->alpha = arg2;
44801 : resultobj = SWIG_Py_Void();
44802 0 : return resultobj;
44803 0 : fail:
44804 : return NULL;
44805 : }
44806 :
44807 :
44808 1 : SWIGINTERN PyObject *_wrap_colorObj_alpha_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44809 : PyObject *resultobj = 0;
44810 : colorObj *arg1 = (colorObj *) 0 ;
44811 1 : void *argp1 = 0 ;
44812 : int res1 = 0 ;
44813 1 : PyObject * obj0 = 0 ;
44814 : int result;
44815 :
44816 1 : if (!PyArg_ParseTuple(args,(char *)"O:colorObj_alpha_get",&obj0)) SWIG_fail;
44817 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44818 1 : if (!SWIG_IsOK(res1)) {
44819 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_alpha_get" "', argument " "1"" of type '" "colorObj *""'");
44820 : }
44821 1 : arg1 = (colorObj *)(argp1);
44822 1 : result = (int) ((arg1)->alpha);
44823 : resultobj = SWIG_From_int((int)(result));
44824 1 : return resultobj;
44825 0 : fail:
44826 : return NULL;
44827 : }
44828 :
44829 :
44830 1 : SWIGINTERN PyObject *_wrap_new_colorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44831 : PyObject *resultobj = 0;
44832 : int arg1 = (int) 0 ;
44833 : int arg2 = (int) 0 ;
44834 : int arg3 = (int) 0 ;
44835 : int arg4 = (int) 255 ;
44836 : int val1 ;
44837 : int ecode1 = 0 ;
44838 : int val2 ;
44839 : int ecode2 = 0 ;
44840 : int val3 ;
44841 : int ecode3 = 0 ;
44842 : int val4 ;
44843 : int ecode4 = 0 ;
44844 1 : PyObject * obj0 = 0 ;
44845 1 : PyObject * obj1 = 0 ;
44846 1 : PyObject * obj2 = 0 ;
44847 1 : PyObject * obj3 = 0 ;
44848 : colorObj *result = 0 ;
44849 :
44850 1 : if (!PyArg_ParseTuple(args,(char *)"|OOOO:new_colorObj",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44851 1 : if (obj0) {
44852 : ecode1 = SWIG_AsVal_int(obj0, &val1);
44853 1 : if (!SWIG_IsOK(ecode1)) {
44854 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_colorObj" "', argument " "1"" of type '" "int""'");
44855 : }
44856 : arg1 = (int)(val1);
44857 : }
44858 1 : if (obj1) {
44859 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44860 1 : if (!SWIG_IsOK(ecode2)) {
44861 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_colorObj" "', argument " "2"" of type '" "int""'");
44862 : }
44863 : arg2 = (int)(val2);
44864 : }
44865 1 : if (obj2) {
44866 : ecode3 = SWIG_AsVal_int(obj2, &val3);
44867 1 : if (!SWIG_IsOK(ecode3)) {
44868 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_colorObj" "', argument " "3"" of type '" "int""'");
44869 : }
44870 : arg3 = (int)(val3);
44871 : }
44872 1 : if (obj3) {
44873 : ecode4 = SWIG_AsVal_int(obj3, &val4);
44874 1 : if (!SWIG_IsOK(ecode4)) {
44875 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_colorObj" "', argument " "4"" of type '" "int""'");
44876 : }
44877 : arg4 = (int)(val4);
44878 : }
44879 : {
44880 1 : result = (colorObj *)new_colorObj(arg1,arg2,arg3,arg4); {
44881 1 : errorObj *ms_error = msGetErrorObj();
44882 :
44883 1 : switch(ms_error->code) {
44884 : case MS_NOERR:
44885 : break;
44886 0 : case MS_NOTFOUND:
44887 0 : msResetErrorList();
44888 0 : break;
44889 : case -1:
44890 : break;
44891 0 : case MS_IOERR:
44892 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44893 0 : _raise_ms_exception();
44894 0 : msResetErrorList();
44895 0 : return NULL;
44896 : }
44897 : default:
44898 0 : _raise_ms_exception();
44899 0 : msResetErrorList();
44900 0 : return NULL;
44901 : }
44902 :
44903 : }
44904 : }
44905 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_colorObj, SWIG_POINTER_NEW | 0 );
44906 1 : return resultobj;
44907 0 : fail:
44908 : return NULL;
44909 : }
44910 :
44911 :
44912 1 : SWIGINTERN PyObject *_wrap_delete_colorObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44913 : PyObject *resultobj = 0;
44914 : colorObj *arg1 = (colorObj *) 0 ;
44915 1 : void *argp1 = 0 ;
44916 : int res1 = 0 ;
44917 1 : PyObject * obj0 = 0 ;
44918 :
44919 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_colorObj",&obj0)) SWIG_fail;
44920 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, SWIG_POINTER_DISOWN | 0 );
44921 1 : if (!SWIG_IsOK(res1)) {
44922 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_colorObj" "', argument " "1"" of type '" "colorObj *""'");
44923 : }
44924 1 : arg1 = (colorObj *)(argp1);
44925 : {
44926 : delete_colorObj(arg1); {
44927 1 : errorObj *ms_error = msGetErrorObj();
44928 :
44929 1 : switch(ms_error->code) {
44930 : case MS_NOERR:
44931 : break;
44932 0 : case MS_NOTFOUND:
44933 0 : msResetErrorList();
44934 0 : break;
44935 : case -1:
44936 : break;
44937 0 : case MS_IOERR:
44938 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
44939 0 : _raise_ms_exception();
44940 0 : msResetErrorList();
44941 0 : return NULL;
44942 : }
44943 : default:
44944 0 : _raise_ms_exception();
44945 0 : msResetErrorList();
44946 0 : return NULL;
44947 : }
44948 :
44949 : }
44950 : }
44951 : resultobj = SWIG_Py_Void();
44952 1 : return resultobj;
44953 0 : fail:
44954 : return NULL;
44955 : }
44956 :
44957 :
44958 1 : SWIGINTERN PyObject *_wrap_colorObj_setRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44959 : PyObject *resultobj = 0;
44960 : colorObj *arg1 = (colorObj *) 0 ;
44961 : int arg2 ;
44962 : int arg3 ;
44963 : int arg4 ;
44964 : int arg5 = (int) 255 ;
44965 1 : void *argp1 = 0 ;
44966 : int res1 = 0 ;
44967 : int val2 ;
44968 : int ecode2 = 0 ;
44969 : int val3 ;
44970 : int ecode3 = 0 ;
44971 : int val4 ;
44972 : int ecode4 = 0 ;
44973 : int val5 ;
44974 : int ecode5 = 0 ;
44975 1 : PyObject * obj0 = 0 ;
44976 1 : PyObject * obj1 = 0 ;
44977 1 : PyObject * obj2 = 0 ;
44978 1 : PyObject * obj3 = 0 ;
44979 1 : PyObject * obj4 = 0 ;
44980 : int result;
44981 :
44982 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO|O:colorObj_setRGB",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44983 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
44984 1 : if (!SWIG_IsOK(res1)) {
44985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_setRGB" "', argument " "1"" of type '" "colorObj *""'");
44986 : }
44987 1 : arg1 = (colorObj *)(argp1);
44988 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
44989 1 : if (!SWIG_IsOK(ecode2)) {
44990 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "colorObj_setRGB" "', argument " "2"" of type '" "int""'");
44991 : }
44992 : arg2 = (int)(val2);
44993 1 : ecode3 = SWIG_AsVal_int(obj2, &val3);
44994 1 : if (!SWIG_IsOK(ecode3)) {
44995 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "colorObj_setRGB" "', argument " "3"" of type '" "int""'");
44996 : }
44997 : arg3 = (int)(val3);
44998 1 : ecode4 = SWIG_AsVal_int(obj3, &val4);
44999 1 : if (!SWIG_IsOK(ecode4)) {
45000 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "colorObj_setRGB" "', argument " "4"" of type '" "int""'");
45001 : }
45002 : arg4 = (int)(val4);
45003 1 : if (obj4) {
45004 : ecode5 = SWIG_AsVal_int(obj4, &val5);
45005 1 : if (!SWIG_IsOK(ecode5)) {
45006 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "colorObj_setRGB" "', argument " "5"" of type '" "int""'");
45007 : }
45008 : arg5 = (int)(val5);
45009 : }
45010 : {
45011 1 : result = (int)colorObj_setRGB(arg1,arg2,arg3,arg4,arg5); {
45012 1 : errorObj *ms_error = msGetErrorObj();
45013 :
45014 1 : switch(ms_error->code) {
45015 : case MS_NOERR:
45016 : break;
45017 0 : case MS_NOTFOUND:
45018 0 : msResetErrorList();
45019 0 : break;
45020 : case -1:
45021 : break;
45022 0 : case MS_IOERR:
45023 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
45024 0 : _raise_ms_exception();
45025 0 : msResetErrorList();
45026 0 : return NULL;
45027 : }
45028 : default:
45029 0 : _raise_ms_exception();
45030 0 : msResetErrorList();
45031 0 : return NULL;
45032 : }
45033 :
45034 : }
45035 : }
45036 : resultobj = SWIG_From_int((int)(result));
45037 1 : return resultobj;
45038 0 : fail:
45039 : return NULL;
45040 : }
45041 :
45042 :
45043 1 : SWIGINTERN PyObject *_wrap_colorObj_setHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45044 : PyObject *resultobj = 0;
45045 : colorObj *arg1 = (colorObj *) 0 ;
45046 : char *arg2 = (char *) 0 ;
45047 1 : void *argp1 = 0 ;
45048 : int res1 = 0 ;
45049 : int res2 ;
45050 1 : char *buf2 = 0 ;
45051 1 : int alloc2 = 0 ;
45052 1 : PyObject * obj0 = 0 ;
45053 1 : PyObject * obj1 = 0 ;
45054 : int result;
45055 :
45056 1 : if (!PyArg_ParseTuple(args,(char *)"OO:colorObj_setHex",&obj0,&obj1)) SWIG_fail;
45057 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
45058 1 : if (!SWIG_IsOK(res1)) {
45059 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_setHex" "', argument " "1"" of type '" "colorObj *""'");
45060 : }
45061 1 : arg1 = (colorObj *)(argp1);
45062 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
45063 1 : if (!SWIG_IsOK(res2)) {
45064 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "colorObj_setHex" "', argument " "2"" of type '" "char *""'");
45065 : }
45066 1 : arg2 = (char *)(buf2);
45067 : {
45068 1 : result = (int)colorObj_setHex(arg1,arg2); {
45069 1 : errorObj *ms_error = msGetErrorObj();
45070 :
45071 1 : switch(ms_error->code) {
45072 : case MS_NOERR:
45073 : break;
45074 0 : case MS_NOTFOUND:
45075 0 : msResetErrorList();
45076 0 : break;
45077 : case -1:
45078 : break;
45079 0 : case MS_IOERR:
45080 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
45081 0 : _raise_ms_exception();
45082 0 : msResetErrorList();
45083 0 : return NULL;
45084 : }
45085 : default:
45086 1 : _raise_ms_exception();
45087 1 : msResetErrorList();
45088 1 : return NULL;
45089 : }
45090 :
45091 : }
45092 : }
45093 : resultobj = SWIG_From_int((int)(result));
45094 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45095 : return resultobj;
45096 0 : fail:
45097 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45098 : return NULL;
45099 : }
45100 :
45101 :
45102 1 : SWIGINTERN PyObject *_wrap_colorObj_toHex(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45103 : PyObject *resultobj = 0;
45104 : colorObj *arg1 = (colorObj *) 0 ;
45105 1 : void *argp1 = 0 ;
45106 : int res1 = 0 ;
45107 1 : PyObject * obj0 = 0 ;
45108 : char *result = 0 ;
45109 :
45110 1 : if (!PyArg_ParseTuple(args,(char *)"O:colorObj_toHex",&obj0)) SWIG_fail;
45111 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_colorObj, 0 | 0 );
45112 1 : if (!SWIG_IsOK(res1)) {
45113 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "colorObj_toHex" "', argument " "1"" of type '" "colorObj *""'");
45114 : }
45115 1 : arg1 = (colorObj *)(argp1);
45116 : {
45117 1 : result = (char *)colorObj_toHex(arg1); {
45118 1 : errorObj *ms_error = msGetErrorObj();
45119 :
45120 1 : switch(ms_error->code) {
45121 : case MS_NOERR:
45122 : break;
45123 0 : case MS_NOTFOUND:
45124 0 : msResetErrorList();
45125 0 : break;
45126 : case -1:
45127 : break;
45128 0 : case MS_IOERR:
45129 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
45130 0 : _raise_ms_exception();
45131 0 : msResetErrorList();
45132 0 : return NULL;
45133 : }
45134 : default:
45135 1 : _raise_ms_exception();
45136 1 : msResetErrorList();
45137 1 : return NULL;
45138 : }
45139 :
45140 : }
45141 : }
45142 1 : resultobj = SWIG_FromCharPtr((const char *)result);
45143 1 : free((char*)result);
45144 1 : return resultobj;
45145 0 : fail:
45146 : return NULL;
45147 : }
45148 :
45149 :
45150 1 : SWIGINTERN PyObject *colorObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45151 : PyObject *obj;
45152 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
45153 1 : SWIG_TypeNewClientData(SWIGTYPE_p_colorObj, SWIG_NewClientData(obj));
45154 1 : return SWIG_Py_Void();
45155 : }
45156 :
45157 0 : SWIGINTERN PyObject *_wrap_symbolObj_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45158 : PyObject *resultobj = 0;
45159 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45160 : char *arg2 = (char *) 0 ;
45161 0 : void *argp1 = 0 ;
45162 : int res1 = 0 ;
45163 : int res2 ;
45164 0 : char *buf2 = 0 ;
45165 0 : int alloc2 = 0 ;
45166 0 : PyObject * obj0 = 0 ;
45167 0 : PyObject * obj1 = 0 ;
45168 :
45169 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_name_set",&obj0,&obj1)) SWIG_fail;
45170 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45171 0 : if (!SWIG_IsOK(res1)) {
45172 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_name_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45173 : }
45174 0 : arg1 = (struct symbolObj *)(argp1);
45175 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
45176 0 : if (!SWIG_IsOK(res2)) {
45177 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_name_set" "', argument " "2"" of type '" "char *""'");
45178 : }
45179 0 : arg2 = (char *)(buf2);
45180 : {
45181 0 : if (arg1->name) free((char*)arg1->name);
45182 0 : if (arg2) {
45183 0 : arg1->name = (char *) malloc(strlen(arg2)+1);
45184 : strcpy((char*)arg1->name,arg2);
45185 : } else {
45186 0 : arg1->name = 0;
45187 : }
45188 : }
45189 : resultobj = SWIG_Py_Void();
45190 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45191 : return resultobj;
45192 0 : fail:
45193 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45194 : return NULL;
45195 : }
45196 :
45197 :
45198 1 : SWIGINTERN PyObject *_wrap_symbolObj_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45199 : PyObject *resultobj = 0;
45200 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45201 1 : void *argp1 = 0 ;
45202 : int res1 = 0 ;
45203 1 : PyObject * obj0 = 0 ;
45204 : char *result = 0 ;
45205 :
45206 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_name_get",&obj0)) SWIG_fail;
45207 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45208 1 : if (!SWIG_IsOK(res1)) {
45209 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_name_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45210 : }
45211 1 : arg1 = (struct symbolObj *)(argp1);
45212 1 : result = (char *) ((arg1)->name);
45213 1 : resultobj = SWIG_FromCharPtr((const char *)result);
45214 1 : return resultobj;
45215 0 : fail:
45216 : return NULL;
45217 : }
45218 :
45219 :
45220 0 : SWIGINTERN PyObject *_wrap_symbolObj_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45221 : PyObject *resultobj = 0;
45222 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45223 : int arg2 ;
45224 0 : void *argp1 = 0 ;
45225 : int res1 = 0 ;
45226 : int val2 ;
45227 : int ecode2 = 0 ;
45228 0 : PyObject * obj0 = 0 ;
45229 0 : PyObject * obj1 = 0 ;
45230 :
45231 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_type_set",&obj0,&obj1)) SWIG_fail;
45232 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45233 0 : if (!SWIG_IsOK(res1)) {
45234 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_type_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45235 : }
45236 0 : arg1 = (struct symbolObj *)(argp1);
45237 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45238 0 : if (!SWIG_IsOK(ecode2)) {
45239 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_type_set" "', argument " "2"" of type '" "int""'");
45240 : }
45241 : arg2 = (int)(val2);
45242 0 : if (arg1) (arg1)->type = arg2;
45243 : resultobj = SWIG_Py_Void();
45244 0 : return resultobj;
45245 0 : fail:
45246 : return NULL;
45247 : }
45248 :
45249 :
45250 1 : SWIGINTERN PyObject *_wrap_symbolObj_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45251 : PyObject *resultobj = 0;
45252 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45253 1 : void *argp1 = 0 ;
45254 : int res1 = 0 ;
45255 1 : PyObject * obj0 = 0 ;
45256 : int result;
45257 :
45258 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_type_get",&obj0)) SWIG_fail;
45259 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45260 1 : if (!SWIG_IsOK(res1)) {
45261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_type_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45262 : }
45263 1 : arg1 = (struct symbolObj *)(argp1);
45264 1 : result = (int) ((arg1)->type);
45265 : resultobj = SWIG_From_int((int)(result));
45266 1 : return resultobj;
45267 0 : fail:
45268 : return NULL;
45269 : }
45270 :
45271 :
45272 0 : SWIGINTERN PyObject *_wrap_symbolObj_inmapfile_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45273 : PyObject *resultobj = 0;
45274 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45275 : int arg2 ;
45276 0 : void *argp1 = 0 ;
45277 : int res1 = 0 ;
45278 : int val2 ;
45279 : int ecode2 = 0 ;
45280 0 : PyObject * obj0 = 0 ;
45281 0 : PyObject * obj1 = 0 ;
45282 :
45283 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_inmapfile_set",&obj0,&obj1)) SWIG_fail;
45284 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45285 0 : if (!SWIG_IsOK(res1)) {
45286 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_inmapfile_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45287 : }
45288 0 : arg1 = (struct symbolObj *)(argp1);
45289 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45290 0 : if (!SWIG_IsOK(ecode2)) {
45291 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_inmapfile_set" "', argument " "2"" of type '" "int""'");
45292 : }
45293 : arg2 = (int)(val2);
45294 0 : if (arg1) (arg1)->inmapfile = arg2;
45295 : resultobj = SWIG_Py_Void();
45296 0 : return resultobj;
45297 0 : fail:
45298 : return NULL;
45299 : }
45300 :
45301 :
45302 0 : SWIGINTERN PyObject *_wrap_symbolObj_inmapfile_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45303 : PyObject *resultobj = 0;
45304 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45305 0 : void *argp1 = 0 ;
45306 : int res1 = 0 ;
45307 0 : PyObject * obj0 = 0 ;
45308 : int result;
45309 :
45310 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_inmapfile_get",&obj0)) SWIG_fail;
45311 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45312 0 : if (!SWIG_IsOK(res1)) {
45313 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_inmapfile_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45314 : }
45315 0 : arg1 = (struct symbolObj *)(argp1);
45316 0 : result = (int) ((arg1)->inmapfile);
45317 : resultobj = SWIG_From_int((int)(result));
45318 0 : return resultobj;
45319 0 : fail:
45320 : return NULL;
45321 : }
45322 :
45323 :
45324 0 : SWIGINTERN PyObject *_wrap_symbolObj_sizex_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45325 : PyObject *resultobj = 0;
45326 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45327 : double arg2 ;
45328 0 : void *argp1 = 0 ;
45329 : int res1 = 0 ;
45330 : double val2 ;
45331 : int ecode2 = 0 ;
45332 0 : PyObject * obj0 = 0 ;
45333 0 : PyObject * obj1 = 0 ;
45334 :
45335 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_sizex_set",&obj0,&obj1)) SWIG_fail;
45336 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45337 0 : if (!SWIG_IsOK(res1)) {
45338 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizex_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45339 : }
45340 0 : arg1 = (struct symbolObj *)(argp1);
45341 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45342 0 : if (!SWIG_IsOK(ecode2)) {
45343 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_sizex_set" "', argument " "2"" of type '" "double""'");
45344 : }
45345 0 : arg2 = (double)(val2);
45346 0 : if (arg1) (arg1)->sizex = arg2;
45347 : resultobj = SWIG_Py_Void();
45348 0 : return resultobj;
45349 0 : fail:
45350 : return NULL;
45351 : }
45352 :
45353 :
45354 0 : SWIGINTERN PyObject *_wrap_symbolObj_sizex_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45355 : PyObject *resultobj = 0;
45356 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45357 0 : void *argp1 = 0 ;
45358 : int res1 = 0 ;
45359 0 : PyObject * obj0 = 0 ;
45360 : double result;
45361 :
45362 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_sizex_get",&obj0)) SWIG_fail;
45363 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45364 0 : if (!SWIG_IsOK(res1)) {
45365 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizex_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45366 : }
45367 0 : arg1 = (struct symbolObj *)(argp1);
45368 0 : result = (double) ((arg1)->sizex);
45369 0 : resultobj = SWIG_From_double((double)(result));
45370 0 : return resultobj;
45371 0 : fail:
45372 : return NULL;
45373 : }
45374 :
45375 :
45376 0 : SWIGINTERN PyObject *_wrap_symbolObj_sizey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45377 : PyObject *resultobj = 0;
45378 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45379 : double arg2 ;
45380 0 : void *argp1 = 0 ;
45381 : int res1 = 0 ;
45382 : double val2 ;
45383 : int ecode2 = 0 ;
45384 0 : PyObject * obj0 = 0 ;
45385 0 : PyObject * obj1 = 0 ;
45386 :
45387 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_sizey_set",&obj0,&obj1)) SWIG_fail;
45388 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45389 0 : if (!SWIG_IsOK(res1)) {
45390 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizey_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45391 : }
45392 0 : arg1 = (struct symbolObj *)(argp1);
45393 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45394 0 : if (!SWIG_IsOK(ecode2)) {
45395 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_sizey_set" "', argument " "2"" of type '" "double""'");
45396 : }
45397 0 : arg2 = (double)(val2);
45398 0 : if (arg1) (arg1)->sizey = arg2;
45399 : resultobj = SWIG_Py_Void();
45400 0 : return resultobj;
45401 0 : fail:
45402 : return NULL;
45403 : }
45404 :
45405 :
45406 0 : SWIGINTERN PyObject *_wrap_symbolObj_sizey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45407 : PyObject *resultobj = 0;
45408 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45409 0 : void *argp1 = 0 ;
45410 : int res1 = 0 ;
45411 0 : PyObject * obj0 = 0 ;
45412 : double result;
45413 :
45414 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_sizey_get",&obj0)) SWIG_fail;
45415 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45416 0 : if (!SWIG_IsOK(res1)) {
45417 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_sizey_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45418 : }
45419 0 : arg1 = (struct symbolObj *)(argp1);
45420 0 : result = (double) ((arg1)->sizey);
45421 0 : resultobj = SWIG_From_double((double)(result));
45422 0 : return resultobj;
45423 0 : fail:
45424 : return NULL;
45425 : }
45426 :
45427 :
45428 0 : SWIGINTERN PyObject *_wrap_symbolObj_minx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45429 : PyObject *resultobj = 0;
45430 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45431 : double arg2 ;
45432 0 : void *argp1 = 0 ;
45433 : int res1 = 0 ;
45434 : double val2 ;
45435 : int ecode2 = 0 ;
45436 0 : PyObject * obj0 = 0 ;
45437 0 : PyObject * obj1 = 0 ;
45438 :
45439 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_minx_set",&obj0,&obj1)) SWIG_fail;
45440 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45441 0 : if (!SWIG_IsOK(res1)) {
45442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_minx_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45443 : }
45444 0 : arg1 = (struct symbolObj *)(argp1);
45445 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45446 0 : if (!SWIG_IsOK(ecode2)) {
45447 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_minx_set" "', argument " "2"" of type '" "double""'");
45448 : }
45449 0 : arg2 = (double)(val2);
45450 0 : if (arg1) (arg1)->minx = arg2;
45451 : resultobj = SWIG_Py_Void();
45452 0 : return resultobj;
45453 0 : fail:
45454 : return NULL;
45455 : }
45456 :
45457 :
45458 0 : SWIGINTERN PyObject *_wrap_symbolObj_minx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45459 : PyObject *resultobj = 0;
45460 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45461 0 : void *argp1 = 0 ;
45462 : int res1 = 0 ;
45463 0 : PyObject * obj0 = 0 ;
45464 : double result;
45465 :
45466 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_minx_get",&obj0)) SWIG_fail;
45467 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45468 0 : if (!SWIG_IsOK(res1)) {
45469 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_minx_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45470 : }
45471 0 : arg1 = (struct symbolObj *)(argp1);
45472 0 : result = (double) ((arg1)->minx);
45473 0 : resultobj = SWIG_From_double((double)(result));
45474 0 : return resultobj;
45475 0 : fail:
45476 : return NULL;
45477 : }
45478 :
45479 :
45480 0 : SWIGINTERN PyObject *_wrap_symbolObj_miny_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45481 : PyObject *resultobj = 0;
45482 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45483 : double arg2 ;
45484 0 : void *argp1 = 0 ;
45485 : int res1 = 0 ;
45486 : double val2 ;
45487 : int ecode2 = 0 ;
45488 0 : PyObject * obj0 = 0 ;
45489 0 : PyObject * obj1 = 0 ;
45490 :
45491 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_miny_set",&obj0,&obj1)) SWIG_fail;
45492 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45493 0 : if (!SWIG_IsOK(res1)) {
45494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_miny_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45495 : }
45496 0 : arg1 = (struct symbolObj *)(argp1);
45497 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45498 0 : if (!SWIG_IsOK(ecode2)) {
45499 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_miny_set" "', argument " "2"" of type '" "double""'");
45500 : }
45501 0 : arg2 = (double)(val2);
45502 0 : if (arg1) (arg1)->miny = arg2;
45503 : resultobj = SWIG_Py_Void();
45504 0 : return resultobj;
45505 0 : fail:
45506 : return NULL;
45507 : }
45508 :
45509 :
45510 0 : SWIGINTERN PyObject *_wrap_symbolObj_miny_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45511 : PyObject *resultobj = 0;
45512 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45513 0 : void *argp1 = 0 ;
45514 : int res1 = 0 ;
45515 0 : PyObject * obj0 = 0 ;
45516 : double result;
45517 :
45518 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_miny_get",&obj0)) SWIG_fail;
45519 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45520 0 : if (!SWIG_IsOK(res1)) {
45521 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_miny_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45522 : }
45523 0 : arg1 = (struct symbolObj *)(argp1);
45524 0 : result = (double) ((arg1)->miny);
45525 0 : resultobj = SWIG_From_double((double)(result));
45526 0 : return resultobj;
45527 0 : fail:
45528 : return NULL;
45529 : }
45530 :
45531 :
45532 0 : SWIGINTERN PyObject *_wrap_symbolObj_maxx_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45533 : PyObject *resultobj = 0;
45534 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45535 : double arg2 ;
45536 0 : void *argp1 = 0 ;
45537 : int res1 = 0 ;
45538 : double val2 ;
45539 : int ecode2 = 0 ;
45540 0 : PyObject * obj0 = 0 ;
45541 0 : PyObject * obj1 = 0 ;
45542 :
45543 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_maxx_set",&obj0,&obj1)) SWIG_fail;
45544 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45545 0 : if (!SWIG_IsOK(res1)) {
45546 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxx_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45547 : }
45548 0 : arg1 = (struct symbolObj *)(argp1);
45549 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45550 0 : if (!SWIG_IsOK(ecode2)) {
45551 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_maxx_set" "', argument " "2"" of type '" "double""'");
45552 : }
45553 0 : arg2 = (double)(val2);
45554 0 : if (arg1) (arg1)->maxx = arg2;
45555 : resultobj = SWIG_Py_Void();
45556 0 : return resultobj;
45557 0 : fail:
45558 : return NULL;
45559 : }
45560 :
45561 :
45562 0 : SWIGINTERN PyObject *_wrap_symbolObj_maxx_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45563 : PyObject *resultobj = 0;
45564 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45565 0 : void *argp1 = 0 ;
45566 : int res1 = 0 ;
45567 0 : PyObject * obj0 = 0 ;
45568 : double result;
45569 :
45570 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_maxx_get",&obj0)) SWIG_fail;
45571 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45572 0 : if (!SWIG_IsOK(res1)) {
45573 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxx_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45574 : }
45575 0 : arg1 = (struct symbolObj *)(argp1);
45576 0 : result = (double) ((arg1)->maxx);
45577 0 : resultobj = SWIG_From_double((double)(result));
45578 0 : return resultobj;
45579 0 : fail:
45580 : return NULL;
45581 : }
45582 :
45583 :
45584 0 : SWIGINTERN PyObject *_wrap_symbolObj_maxy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45585 : PyObject *resultobj = 0;
45586 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45587 : double arg2 ;
45588 0 : void *argp1 = 0 ;
45589 : int res1 = 0 ;
45590 : double val2 ;
45591 : int ecode2 = 0 ;
45592 0 : PyObject * obj0 = 0 ;
45593 0 : PyObject * obj1 = 0 ;
45594 :
45595 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_maxy_set",&obj0,&obj1)) SWIG_fail;
45596 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45597 0 : if (!SWIG_IsOK(res1)) {
45598 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxy_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45599 : }
45600 0 : arg1 = (struct symbolObj *)(argp1);
45601 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45602 0 : if (!SWIG_IsOK(ecode2)) {
45603 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_maxy_set" "', argument " "2"" of type '" "double""'");
45604 : }
45605 0 : arg2 = (double)(val2);
45606 0 : if (arg1) (arg1)->maxy = arg2;
45607 : resultobj = SWIG_Py_Void();
45608 0 : return resultobj;
45609 0 : fail:
45610 : return NULL;
45611 : }
45612 :
45613 :
45614 0 : SWIGINTERN PyObject *_wrap_symbolObj_maxy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45615 : PyObject *resultobj = 0;
45616 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45617 0 : void *argp1 = 0 ;
45618 : int res1 = 0 ;
45619 0 : PyObject * obj0 = 0 ;
45620 : double result;
45621 :
45622 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_maxy_get",&obj0)) SWIG_fail;
45623 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45624 0 : if (!SWIG_IsOK(res1)) {
45625 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_maxy_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45626 : }
45627 0 : arg1 = (struct symbolObj *)(argp1);
45628 0 : result = (double) ((arg1)->maxy);
45629 0 : resultobj = SWIG_From_double((double)(result));
45630 0 : return resultobj;
45631 0 : fail:
45632 : return NULL;
45633 : }
45634 :
45635 :
45636 1 : SWIGINTERN PyObject *_wrap_symbolObj_refcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45637 : PyObject *resultobj = 0;
45638 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45639 1 : void *argp1 = 0 ;
45640 : int res1 = 0 ;
45641 1 : PyObject * obj0 = 0 ;
45642 : int result;
45643 :
45644 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_refcount_get",&obj0)) SWIG_fail;
45645 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45646 1 : if (!SWIG_IsOK(res1)) {
45647 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_refcount_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45648 : }
45649 1 : arg1 = (struct symbolObj *)(argp1);
45650 1 : result = (int) ((arg1)->refcount);
45651 : resultobj = SWIG_From_int((int)(result));
45652 1 : return resultobj;
45653 0 : fail:
45654 : return NULL;
45655 : }
45656 :
45657 :
45658 1 : SWIGINTERN PyObject *_wrap_symbolObj_numpoints_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45659 : PyObject *resultobj = 0;
45660 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45661 1 : void *argp1 = 0 ;
45662 : int res1 = 0 ;
45663 1 : PyObject * obj0 = 0 ;
45664 : int result;
45665 :
45666 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_numpoints_get",&obj0)) SWIG_fail;
45667 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45668 1 : if (!SWIG_IsOK(res1)) {
45669 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_numpoints_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45670 : }
45671 1 : arg1 = (struct symbolObj *)(argp1);
45672 1 : result = (int) ((arg1)->numpoints);
45673 : resultobj = SWIG_From_int((int)(result));
45674 1 : return resultobj;
45675 0 : fail:
45676 : return NULL;
45677 : }
45678 :
45679 :
45680 0 : SWIGINTERN PyObject *_wrap_symbolObj_filled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45681 : PyObject *resultobj = 0;
45682 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45683 : int arg2 ;
45684 0 : void *argp1 = 0 ;
45685 : int res1 = 0 ;
45686 : int val2 ;
45687 : int ecode2 = 0 ;
45688 0 : PyObject * obj0 = 0 ;
45689 0 : PyObject * obj1 = 0 ;
45690 :
45691 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_filled_set",&obj0,&obj1)) SWIG_fail;
45692 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45693 0 : if (!SWIG_IsOK(res1)) {
45694 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_filled_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45695 : }
45696 0 : arg1 = (struct symbolObj *)(argp1);
45697 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45698 0 : if (!SWIG_IsOK(ecode2)) {
45699 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_filled_set" "', argument " "2"" of type '" "int""'");
45700 : }
45701 : arg2 = (int)(val2);
45702 0 : if (arg1) (arg1)->filled = arg2;
45703 : resultobj = SWIG_Py_Void();
45704 0 : return resultobj;
45705 0 : fail:
45706 : return NULL;
45707 : }
45708 :
45709 :
45710 0 : SWIGINTERN PyObject *_wrap_symbolObj_filled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45711 : PyObject *resultobj = 0;
45712 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45713 0 : void *argp1 = 0 ;
45714 : int res1 = 0 ;
45715 0 : PyObject * obj0 = 0 ;
45716 : int result;
45717 :
45718 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_filled_get",&obj0)) SWIG_fail;
45719 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45720 0 : if (!SWIG_IsOK(res1)) {
45721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_filled_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45722 : }
45723 0 : arg1 = (struct symbolObj *)(argp1);
45724 0 : result = (int) ((arg1)->filled);
45725 : resultobj = SWIG_From_int((int)(result));
45726 0 : return resultobj;
45727 0 : fail:
45728 : return NULL;
45729 : }
45730 :
45731 :
45732 0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45733 : PyObject *resultobj = 0;
45734 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45735 : double arg2 ;
45736 0 : void *argp1 = 0 ;
45737 : int res1 = 0 ;
45738 : double val2 ;
45739 : int ecode2 = 0 ;
45740 0 : PyObject * obj0 = 0 ;
45741 0 : PyObject * obj1 = 0 ;
45742 :
45743 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_anchorpoint_x_set",&obj0,&obj1)) SWIG_fail;
45744 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45745 0 : if (!SWIG_IsOK(res1)) {
45746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_x_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45747 : }
45748 0 : arg1 = (struct symbolObj *)(argp1);
45749 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45750 0 : if (!SWIG_IsOK(ecode2)) {
45751 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_anchorpoint_x_set" "', argument " "2"" of type '" "double""'");
45752 : }
45753 0 : arg2 = (double)(val2);
45754 0 : if (arg1) (arg1)->anchorpoint_x = arg2;
45755 : resultobj = SWIG_Py_Void();
45756 0 : return resultobj;
45757 0 : fail:
45758 : return NULL;
45759 : }
45760 :
45761 :
45762 0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45763 : PyObject *resultobj = 0;
45764 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45765 0 : void *argp1 = 0 ;
45766 : int res1 = 0 ;
45767 0 : PyObject * obj0 = 0 ;
45768 : double result;
45769 :
45770 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_anchorpoint_x_get",&obj0)) SWIG_fail;
45771 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45772 0 : if (!SWIG_IsOK(res1)) {
45773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_x_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45774 : }
45775 0 : arg1 = (struct symbolObj *)(argp1);
45776 0 : result = (double) ((arg1)->anchorpoint_x);
45777 0 : resultobj = SWIG_From_double((double)(result));
45778 0 : return resultobj;
45779 0 : fail:
45780 : return NULL;
45781 : }
45782 :
45783 :
45784 0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45785 : PyObject *resultobj = 0;
45786 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45787 : double arg2 ;
45788 0 : void *argp1 = 0 ;
45789 : int res1 = 0 ;
45790 : double val2 ;
45791 : int ecode2 = 0 ;
45792 0 : PyObject * obj0 = 0 ;
45793 0 : PyObject * obj1 = 0 ;
45794 :
45795 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_anchorpoint_y_set",&obj0,&obj1)) SWIG_fail;
45796 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45797 0 : if (!SWIG_IsOK(res1)) {
45798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_y_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45799 : }
45800 0 : arg1 = (struct symbolObj *)(argp1);
45801 0 : ecode2 = SWIG_AsVal_double(obj1, &val2);
45802 0 : if (!SWIG_IsOK(ecode2)) {
45803 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_anchorpoint_y_set" "', argument " "2"" of type '" "double""'");
45804 : }
45805 0 : arg2 = (double)(val2);
45806 0 : if (arg1) (arg1)->anchorpoint_y = arg2;
45807 : resultobj = SWIG_Py_Void();
45808 0 : return resultobj;
45809 0 : fail:
45810 : return NULL;
45811 : }
45812 :
45813 :
45814 0 : SWIGINTERN PyObject *_wrap_symbolObj_anchorpoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45815 : PyObject *resultobj = 0;
45816 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45817 0 : void *argp1 = 0 ;
45818 : int res1 = 0 ;
45819 0 : PyObject * obj0 = 0 ;
45820 : double result;
45821 :
45822 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_anchorpoint_y_get",&obj0)) SWIG_fail;
45823 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45824 0 : if (!SWIG_IsOK(res1)) {
45825 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_anchorpoint_y_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45826 : }
45827 0 : arg1 = (struct symbolObj *)(argp1);
45828 0 : result = (double) ((arg1)->anchorpoint_y);
45829 0 : resultobj = SWIG_From_double((double)(result));
45830 0 : return resultobj;
45831 0 : fail:
45832 : return NULL;
45833 : }
45834 :
45835 :
45836 0 : SWIGINTERN PyObject *_wrap_symbolObj_imagepath_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45837 : PyObject *resultobj = 0;
45838 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45839 0 : void *argp1 = 0 ;
45840 : int res1 = 0 ;
45841 0 : PyObject * obj0 = 0 ;
45842 : char *result = 0 ;
45843 :
45844 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_imagepath_get",&obj0)) SWIG_fail;
45845 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45846 0 : if (!SWIG_IsOK(res1)) {
45847 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_imagepath_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45848 : }
45849 0 : arg1 = (struct symbolObj *)(argp1);
45850 0 : result = (char *) ((arg1)->imagepath);
45851 0 : resultobj = SWIG_FromCharPtr((const char *)result);
45852 0 : return resultobj;
45853 0 : fail:
45854 : return NULL;
45855 : }
45856 :
45857 :
45858 0 : SWIGINTERN PyObject *_wrap_symbolObj_transparent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45859 : PyObject *resultobj = 0;
45860 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45861 : int arg2 ;
45862 0 : void *argp1 = 0 ;
45863 : int res1 = 0 ;
45864 : int val2 ;
45865 : int ecode2 = 0 ;
45866 0 : PyObject * obj0 = 0 ;
45867 0 : PyObject * obj1 = 0 ;
45868 :
45869 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_transparent_set",&obj0,&obj1)) SWIG_fail;
45870 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45871 0 : if (!SWIG_IsOK(res1)) {
45872 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparent_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45873 : }
45874 0 : arg1 = (struct symbolObj *)(argp1);
45875 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45876 0 : if (!SWIG_IsOK(ecode2)) {
45877 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_transparent_set" "', argument " "2"" of type '" "int""'");
45878 : }
45879 : arg2 = (int)(val2);
45880 0 : if (arg1) (arg1)->transparent = arg2;
45881 : resultobj = SWIG_Py_Void();
45882 0 : return resultobj;
45883 0 : fail:
45884 : return NULL;
45885 : }
45886 :
45887 :
45888 0 : SWIGINTERN PyObject *_wrap_symbolObj_transparent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45889 : PyObject *resultobj = 0;
45890 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45891 0 : void *argp1 = 0 ;
45892 : int res1 = 0 ;
45893 0 : PyObject * obj0 = 0 ;
45894 : int result;
45895 :
45896 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_transparent_get",&obj0)) SWIG_fail;
45897 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45898 0 : if (!SWIG_IsOK(res1)) {
45899 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparent_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45900 : }
45901 0 : arg1 = (struct symbolObj *)(argp1);
45902 0 : result = (int) ((arg1)->transparent);
45903 : resultobj = SWIG_From_int((int)(result));
45904 0 : return resultobj;
45905 0 : fail:
45906 : return NULL;
45907 : }
45908 :
45909 :
45910 0 : SWIGINTERN PyObject *_wrap_symbolObj_transparentcolor_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45911 : PyObject *resultobj = 0;
45912 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45913 : int arg2 ;
45914 0 : void *argp1 = 0 ;
45915 : int res1 = 0 ;
45916 : int val2 ;
45917 : int ecode2 = 0 ;
45918 0 : PyObject * obj0 = 0 ;
45919 0 : PyObject * obj1 = 0 ;
45920 :
45921 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_transparentcolor_set",&obj0,&obj1)) SWIG_fail;
45922 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45923 0 : if (!SWIG_IsOK(res1)) {
45924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparentcolor_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45925 : }
45926 0 : arg1 = (struct symbolObj *)(argp1);
45927 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
45928 0 : if (!SWIG_IsOK(ecode2)) {
45929 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "symbolObj_transparentcolor_set" "', argument " "2"" of type '" "int""'");
45930 : }
45931 : arg2 = (int)(val2);
45932 0 : if (arg1) (arg1)->transparentcolor = arg2;
45933 : resultobj = SWIG_Py_Void();
45934 0 : return resultobj;
45935 0 : fail:
45936 : return NULL;
45937 : }
45938 :
45939 :
45940 0 : SWIGINTERN PyObject *_wrap_symbolObj_transparentcolor_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45941 : PyObject *resultobj = 0;
45942 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45943 0 : void *argp1 = 0 ;
45944 : int res1 = 0 ;
45945 0 : PyObject * obj0 = 0 ;
45946 : int result;
45947 :
45948 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_transparentcolor_get",&obj0)) SWIG_fail;
45949 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45950 0 : if (!SWIG_IsOK(res1)) {
45951 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_transparentcolor_get" "', argument " "1"" of type '" "struct symbolObj *""'");
45952 : }
45953 0 : arg1 = (struct symbolObj *)(argp1);
45954 0 : result = (int) ((arg1)->transparentcolor);
45955 : resultobj = SWIG_From_int((int)(result));
45956 0 : return resultobj;
45957 0 : fail:
45958 : return NULL;
45959 : }
45960 :
45961 :
45962 0 : SWIGINTERN PyObject *_wrap_symbolObj_character_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45963 : PyObject *resultobj = 0;
45964 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
45965 : char *arg2 = (char *) 0 ;
45966 0 : void *argp1 = 0 ;
45967 : int res1 = 0 ;
45968 : int res2 ;
45969 0 : char *buf2 = 0 ;
45970 0 : int alloc2 = 0 ;
45971 0 : PyObject * obj0 = 0 ;
45972 0 : PyObject * obj1 = 0 ;
45973 :
45974 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_character_set",&obj0,&obj1)) SWIG_fail;
45975 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
45976 0 : if (!SWIG_IsOK(res1)) {
45977 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_character_set" "', argument " "1"" of type '" "struct symbolObj *""'");
45978 : }
45979 0 : arg1 = (struct symbolObj *)(argp1);
45980 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
45981 0 : if (!SWIG_IsOK(res2)) {
45982 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_character_set" "', argument " "2"" of type '" "char *""'");
45983 : }
45984 0 : arg2 = (char *)(buf2);
45985 : {
45986 0 : if (arg1->character) free((char*)arg1->character);
45987 0 : if (arg2) {
45988 0 : arg1->character = (char *) malloc(strlen(arg2)+1);
45989 : strcpy((char*)arg1->character,arg2);
45990 : } else {
45991 0 : arg1->character = 0;
45992 : }
45993 : }
45994 : resultobj = SWIG_Py_Void();
45995 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45996 : return resultobj;
45997 0 : fail:
45998 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
45999 : return NULL;
46000 : }
46001 :
46002 :
46003 0 : SWIGINTERN PyObject *_wrap_symbolObj_character_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46004 : PyObject *resultobj = 0;
46005 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46006 0 : void *argp1 = 0 ;
46007 : int res1 = 0 ;
46008 0 : PyObject * obj0 = 0 ;
46009 : char *result = 0 ;
46010 :
46011 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_character_get",&obj0)) SWIG_fail;
46012 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46013 0 : if (!SWIG_IsOK(res1)) {
46014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_character_get" "', argument " "1"" of type '" "struct symbolObj *""'");
46015 : }
46016 0 : arg1 = (struct symbolObj *)(argp1);
46017 0 : result = (char *) ((arg1)->character);
46018 0 : resultobj = SWIG_FromCharPtr((const char *)result);
46019 0 : return resultobj;
46020 0 : fail:
46021 : return NULL;
46022 : }
46023 :
46024 :
46025 0 : SWIGINTERN PyObject *_wrap_symbolObj_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46026 : PyObject *resultobj = 0;
46027 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46028 : char *arg2 = (char *) 0 ;
46029 0 : void *argp1 = 0 ;
46030 : int res1 = 0 ;
46031 : int res2 ;
46032 0 : char *buf2 = 0 ;
46033 0 : int alloc2 = 0 ;
46034 0 : PyObject * obj0 = 0 ;
46035 0 : PyObject * obj1 = 0 ;
46036 :
46037 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_font_set",&obj0,&obj1)) SWIG_fail;
46038 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46039 0 : if (!SWIG_IsOK(res1)) {
46040 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_font_set" "', argument " "1"" of type '" "struct symbolObj *""'");
46041 : }
46042 0 : arg1 = (struct symbolObj *)(argp1);
46043 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46044 0 : if (!SWIG_IsOK(res2)) {
46045 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_font_set" "', argument " "2"" of type '" "char *""'");
46046 : }
46047 0 : arg2 = (char *)(buf2);
46048 : {
46049 0 : if (arg1->font) free((char*)arg1->font);
46050 0 : if (arg2) {
46051 0 : arg1->font = (char *) malloc(strlen(arg2)+1);
46052 : strcpy((char*)arg1->font,arg2);
46053 : } else {
46054 0 : arg1->font = 0;
46055 : }
46056 : }
46057 : resultobj = SWIG_Py_Void();
46058 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46059 : return resultobj;
46060 0 : fail:
46061 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46062 : return NULL;
46063 : }
46064 :
46065 :
46066 0 : SWIGINTERN PyObject *_wrap_symbolObj_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46067 : PyObject *resultobj = 0;
46068 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46069 0 : void *argp1 = 0 ;
46070 : int res1 = 0 ;
46071 0 : PyObject * obj0 = 0 ;
46072 : char *result = 0 ;
46073 :
46074 0 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_font_get",&obj0)) SWIG_fail;
46075 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46076 0 : if (!SWIG_IsOK(res1)) {
46077 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_font_get" "', argument " "1"" of type '" "struct symbolObj *""'");
46078 : }
46079 0 : arg1 = (struct symbolObj *)(argp1);
46080 0 : result = (char *) ((arg1)->font);
46081 0 : resultobj = SWIG_FromCharPtr((const char *)result);
46082 0 : return resultobj;
46083 0 : fail:
46084 : return NULL;
46085 : }
46086 :
46087 :
46088 1 : SWIGINTERN PyObject *_wrap_new_symbolObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46089 : PyObject *resultobj = 0;
46090 : char *arg1 = (char *) 0 ;
46091 : char *arg2 = (char *) NULL ;
46092 : int res1 ;
46093 1 : char *buf1 = 0 ;
46094 1 : int alloc1 = 0 ;
46095 : int res2 ;
46096 1 : char *buf2 = 0 ;
46097 1 : int alloc2 = 0 ;
46098 1 : PyObject * obj0 = 0 ;
46099 1 : PyObject * obj1 = 0 ;
46100 : struct symbolObj *result = 0 ;
46101 :
46102 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:new_symbolObj",&obj0,&obj1)) SWIG_fail;
46103 1 : res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
46104 1 : if (!SWIG_IsOK(res1)) {
46105 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_symbolObj" "', argument " "1"" of type '" "char *""'");
46106 : }
46107 1 : arg1 = (char *)(buf1);
46108 1 : if (obj1) {
46109 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46110 1 : if (!SWIG_IsOK(res2)) {
46111 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_symbolObj" "', argument " "2"" of type '" "char const *""'");
46112 : }
46113 1 : arg2 = (char *)(buf2);
46114 : }
46115 : {
46116 1 : result = (struct symbolObj *)new_symbolObj(arg1,(char const *)arg2); {
46117 1 : errorObj *ms_error = msGetErrorObj();
46118 :
46119 1 : switch(ms_error->code) {
46120 : case MS_NOERR:
46121 : break;
46122 0 : case MS_NOTFOUND:
46123 0 : msResetErrorList();
46124 0 : break;
46125 : case -1:
46126 : break;
46127 0 : case MS_IOERR:
46128 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46129 0 : _raise_ms_exception();
46130 0 : msResetErrorList();
46131 0 : return NULL;
46132 : }
46133 : default:
46134 0 : _raise_ms_exception();
46135 0 : msResetErrorList();
46136 0 : return NULL;
46137 : }
46138 :
46139 : }
46140 : }
46141 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_symbolObj, SWIG_POINTER_NEW | 0 );
46142 1 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
46143 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46144 : return resultobj;
46145 0 : fail:
46146 0 : if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
46147 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46148 : return NULL;
46149 : }
46150 :
46151 :
46152 1 : SWIGINTERN PyObject *_wrap_delete_symbolObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46153 : PyObject *resultobj = 0;
46154 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46155 1 : void *argp1 = 0 ;
46156 : int res1 = 0 ;
46157 1 : PyObject * obj0 = 0 ;
46158 :
46159 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_symbolObj",&obj0)) SWIG_fail;
46160 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, SWIG_POINTER_DISOWN | 0 );
46161 1 : if (!SWIG_IsOK(res1)) {
46162 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_symbolObj" "', argument " "1"" of type '" "struct symbolObj *""'");
46163 : }
46164 1 : arg1 = (struct symbolObj *)(argp1);
46165 : {
46166 1 : delete_symbolObj(arg1); {
46167 1 : errorObj *ms_error = msGetErrorObj();
46168 :
46169 1 : switch(ms_error->code) {
46170 : case MS_NOERR:
46171 : break;
46172 0 : case MS_NOTFOUND:
46173 0 : msResetErrorList();
46174 0 : break;
46175 : case -1:
46176 : break;
46177 0 : case MS_IOERR:
46178 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46179 0 : _raise_ms_exception();
46180 0 : msResetErrorList();
46181 0 : return NULL;
46182 : }
46183 : default:
46184 0 : _raise_ms_exception();
46185 0 : msResetErrorList();
46186 0 : return NULL;
46187 : }
46188 :
46189 : }
46190 : }
46191 : resultobj = SWIG_Py_Void();
46192 1 : return resultobj;
46193 0 : fail:
46194 : return NULL;
46195 : }
46196 :
46197 :
46198 1 : SWIGINTERN PyObject *_wrap_symbolObj_setImagepath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46199 : PyObject *resultobj = 0;
46200 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46201 : char *arg2 = (char *) 0 ;
46202 1 : void *argp1 = 0 ;
46203 : int res1 = 0 ;
46204 : int res2 ;
46205 1 : char *buf2 = 0 ;
46206 1 : int alloc2 = 0 ;
46207 1 : PyObject * obj0 = 0 ;
46208 1 : PyObject * obj1 = 0 ;
46209 : int result;
46210 :
46211 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setImagepath",&obj0,&obj1)) SWIG_fail;
46212 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46213 1 : if (!SWIG_IsOK(res1)) {
46214 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setImagepath" "', argument " "1"" of type '" "struct symbolObj *""'");
46215 : }
46216 1 : arg1 = (struct symbolObj *)(argp1);
46217 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46218 1 : if (!SWIG_IsOK(res2)) {
46219 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setImagepath" "', argument " "2"" of type '" "char const *""'");
46220 : }
46221 1 : arg2 = (char *)(buf2);
46222 : {
46223 : result = (int)symbolObj_setImagepath(arg1,(char const *)arg2); {
46224 1 : errorObj *ms_error = msGetErrorObj();
46225 :
46226 1 : switch(ms_error->code) {
46227 : case MS_NOERR:
46228 : break;
46229 0 : case MS_NOTFOUND:
46230 0 : msResetErrorList();
46231 0 : break;
46232 : case -1:
46233 : break;
46234 0 : case MS_IOERR:
46235 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46236 0 : _raise_ms_exception();
46237 0 : msResetErrorList();
46238 0 : return NULL;
46239 : }
46240 : default:
46241 0 : _raise_ms_exception();
46242 0 : msResetErrorList();
46243 0 : return NULL;
46244 : }
46245 :
46246 : }
46247 : }
46248 : resultobj = SWIG_From_int((int)(result));
46249 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46250 : return resultobj;
46251 0 : fail:
46252 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46253 : return NULL;
46254 : }
46255 :
46256 :
46257 1 : SWIGINTERN PyObject *_wrap_symbolObj_setPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46258 : PyObject *resultobj = 0;
46259 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46260 : lineObj *arg2 = (lineObj *) 0 ;
46261 1 : void *argp1 = 0 ;
46262 : int res1 = 0 ;
46263 1 : void *argp2 = 0 ;
46264 : int res2 = 0 ;
46265 1 : PyObject * obj0 = 0 ;
46266 1 : PyObject * obj1 = 0 ;
46267 : int result;
46268 :
46269 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setPoints",&obj0,&obj1)) SWIG_fail;
46270 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46271 1 : if (!SWIG_IsOK(res1)) {
46272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setPoints" "', argument " "1"" of type '" "struct symbolObj *""'");
46273 : }
46274 1 : arg1 = (struct symbolObj *)(argp1);
46275 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_lineObj, 0 | 0 );
46276 1 : if (!SWIG_IsOK(res2)) {
46277 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setPoints" "', argument " "2"" of type '" "lineObj *""'");
46278 : }
46279 1 : arg2 = (lineObj *)(argp2);
46280 : {
46281 1 : result = (int)symbolObj_setPoints(arg1,arg2); {
46282 1 : errorObj *ms_error = msGetErrorObj();
46283 :
46284 1 : switch(ms_error->code) {
46285 : case MS_NOERR:
46286 : break;
46287 0 : case MS_NOTFOUND:
46288 0 : msResetErrorList();
46289 0 : break;
46290 : case -1:
46291 : break;
46292 0 : case MS_IOERR:
46293 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46294 0 : _raise_ms_exception();
46295 0 : msResetErrorList();
46296 0 : return NULL;
46297 : }
46298 : default:
46299 0 : _raise_ms_exception();
46300 0 : msResetErrorList();
46301 0 : return NULL;
46302 : }
46303 :
46304 : }
46305 : }
46306 : resultobj = SWIG_From_int((int)(result));
46307 1 : return resultobj;
46308 0 : fail:
46309 : return NULL;
46310 : }
46311 :
46312 :
46313 1 : SWIGINTERN PyObject *_wrap_symbolObj_getPoints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46314 : PyObject *resultobj = 0;
46315 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46316 1 : void *argp1 = 0 ;
46317 : int res1 = 0 ;
46318 1 : PyObject * obj0 = 0 ;
46319 : lineObj *result = 0 ;
46320 :
46321 1 : if (!PyArg_ParseTuple(args,(char *)"O:symbolObj_getPoints",&obj0)) SWIG_fail;
46322 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46323 1 : if (!SWIG_IsOK(res1)) {
46324 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_getPoints" "', argument " "1"" of type '" "struct symbolObj *""'");
46325 : }
46326 1 : arg1 = (struct symbolObj *)(argp1);
46327 : {
46328 1 : result = (lineObj *)symbolObj_getPoints(arg1); {
46329 1 : errorObj *ms_error = msGetErrorObj();
46330 :
46331 1 : switch(ms_error->code) {
46332 : case MS_NOERR:
46333 : break;
46334 0 : case MS_NOTFOUND:
46335 0 : msResetErrorList();
46336 0 : break;
46337 : case -1:
46338 : break;
46339 0 : case MS_IOERR:
46340 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46341 0 : _raise_ms_exception();
46342 0 : msResetErrorList();
46343 0 : return NULL;
46344 : }
46345 : default:
46346 0 : _raise_ms_exception();
46347 0 : msResetErrorList();
46348 0 : return NULL;
46349 : }
46350 :
46351 : }
46352 : }
46353 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_lineObj, SWIG_POINTER_OWN | 0 );
46354 1 : return resultobj;
46355 0 : fail:
46356 : return NULL;
46357 : }
46358 :
46359 :
46360 1 : SWIGINTERN PyObject *_wrap_symbolObj_getImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46361 : PyObject *resultobj = 0;
46362 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46363 : outputFormatObj *arg2 = (outputFormatObj *) 0 ;
46364 1 : void *argp1 = 0 ;
46365 : int res1 = 0 ;
46366 1 : void *argp2 = 0 ;
46367 : int res2 = 0 ;
46368 1 : PyObject * obj0 = 0 ;
46369 1 : PyObject * obj1 = 0 ;
46370 : imageObj *result = 0 ;
46371 :
46372 1 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_getImage",&obj0,&obj1)) SWIG_fail;
46373 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46374 1 : if (!SWIG_IsOK(res1)) {
46375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_getImage" "', argument " "1"" of type '" "struct symbolObj *""'");
46376 : }
46377 1 : arg1 = (struct symbolObj *)(argp1);
46378 1 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_outputFormatObj, 0 | 0 );
46379 1 : if (!SWIG_IsOK(res2)) {
46380 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_getImage" "', argument " "2"" of type '" "outputFormatObj *""'");
46381 : }
46382 1 : arg2 = (outputFormatObj *)(argp2);
46383 : {
46384 1 : result = (imageObj *)symbolObj_getImage(arg1,arg2); {
46385 1 : errorObj *ms_error = msGetErrorObj();
46386 :
46387 1 : switch(ms_error->code) {
46388 : case MS_NOERR:
46389 : break;
46390 0 : case MS_NOTFOUND:
46391 0 : msResetErrorList();
46392 0 : break;
46393 : case -1:
46394 : break;
46395 0 : case MS_IOERR:
46396 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46397 0 : _raise_ms_exception();
46398 0 : msResetErrorList();
46399 0 : return NULL;
46400 : }
46401 : default:
46402 0 : _raise_ms_exception();
46403 0 : msResetErrorList();
46404 0 : return NULL;
46405 : }
46406 :
46407 : }
46408 : }
46409 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_imageObj, SWIG_POINTER_OWN | 0 );
46410 1 : return resultobj;
46411 0 : fail:
46412 : return NULL;
46413 : }
46414 :
46415 :
46416 0 : SWIGINTERN PyObject *_wrap_symbolObj_setImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46417 : PyObject *resultobj = 0;
46418 : struct symbolObj *arg1 = (struct symbolObj *) 0 ;
46419 : imageObj *arg2 = (imageObj *) 0 ;
46420 0 : void *argp1 = 0 ;
46421 : int res1 = 0 ;
46422 0 : void *argp2 = 0 ;
46423 : int res2 = 0 ;
46424 0 : PyObject * obj0 = 0 ;
46425 0 : PyObject * obj1 = 0 ;
46426 : int result;
46427 :
46428 0 : if (!PyArg_ParseTuple(args,(char *)"OO:symbolObj_setImage",&obj0,&obj1)) SWIG_fail;
46429 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_symbolObj, 0 | 0 );
46430 0 : if (!SWIG_IsOK(res1)) {
46431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "symbolObj_setImage" "', argument " "1"" of type '" "struct symbolObj *""'");
46432 : }
46433 0 : arg1 = (struct symbolObj *)(argp1);
46434 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_imageObj, 0 | 0 );
46435 0 : if (!SWIG_IsOK(res2)) {
46436 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "symbolObj_setImage" "', argument " "2"" of type '" "imageObj *""'");
46437 : }
46438 0 : arg2 = (imageObj *)(argp2);
46439 : {
46440 0 : result = (int)symbolObj_setImage(arg1,arg2); {
46441 0 : errorObj *ms_error = msGetErrorObj();
46442 :
46443 0 : switch(ms_error->code) {
46444 : case MS_NOERR:
46445 : break;
46446 0 : case MS_NOTFOUND:
46447 0 : msResetErrorList();
46448 0 : break;
46449 : case -1:
46450 : break;
46451 0 : case MS_IOERR:
46452 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46453 0 : _raise_ms_exception();
46454 0 : msResetErrorList();
46455 0 : return NULL;
46456 : }
46457 : default:
46458 0 : _raise_ms_exception();
46459 0 : msResetErrorList();
46460 0 : return NULL;
46461 : }
46462 :
46463 : }
46464 : }
46465 : resultobj = SWIG_From_int((int)(result));
46466 0 : return resultobj;
46467 0 : fail:
46468 : return NULL;
46469 : }
46470 :
46471 :
46472 1 : SWIGINTERN PyObject *symbolObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46473 : PyObject *obj;
46474 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
46475 1 : SWIG_TypeNewClientData(SWIGTYPE_p_symbolObj, SWIG_NewClientData(obj));
46476 1 : return SWIG_Py_Void();
46477 : }
46478 :
46479 1 : SWIGINTERN PyObject *_wrap_hashTableObj_numitems_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46480 : PyObject *resultobj = 0;
46481 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46482 1 : void *argp1 = 0 ;
46483 : int res1 = 0 ;
46484 1 : PyObject * obj0 = 0 ;
46485 : int result;
46486 :
46487 1 : if (!PyArg_ParseTuple(args,(char *)"O:hashTableObj_numitems_get",&obj0)) SWIG_fail;
46488 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46489 1 : if (!SWIG_IsOK(res1)) {
46490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_numitems_get" "', argument " "1"" of type '" "hashTableObj *""'");
46491 : }
46492 1 : arg1 = (hashTableObj *)(argp1);
46493 1 : result = (int) ((arg1)->numitems);
46494 : resultobj = SWIG_From_int((int)(result));
46495 1 : return resultobj;
46496 0 : fail:
46497 : return NULL;
46498 : }
46499 :
46500 :
46501 1 : SWIGINTERN PyObject *_wrap_new_hashTableObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46502 : PyObject *resultobj = 0;
46503 : hashTableObj *result = 0 ;
46504 :
46505 1 : if (!PyArg_ParseTuple(args,(char *)":new_hashTableObj")) SWIG_fail;
46506 : {
46507 : result = (hashTableObj *)new_hashTableObj(); {
46508 1 : errorObj *ms_error = msGetErrorObj();
46509 :
46510 1 : switch(ms_error->code) {
46511 : case MS_NOERR:
46512 : break;
46513 0 : case MS_NOTFOUND:
46514 0 : msResetErrorList();
46515 0 : break;
46516 : case -1:
46517 : break;
46518 0 : case MS_IOERR:
46519 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46520 0 : _raise_ms_exception();
46521 0 : msResetErrorList();
46522 0 : return NULL;
46523 : }
46524 : default:
46525 0 : _raise_ms_exception();
46526 0 : msResetErrorList();
46527 0 : return NULL;
46528 : }
46529 :
46530 : }
46531 : }
46532 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, SWIG_POINTER_NEW | 0 );
46533 1 : return resultobj;
46534 1 : fail:
46535 : return NULL;
46536 : }
46537 :
46538 :
46539 1 : SWIGINTERN PyObject *_wrap_delete_hashTableObj(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46540 : PyObject *resultobj = 0;
46541 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46542 1 : void *argp1 = 0 ;
46543 : int res1 = 0 ;
46544 1 : PyObject * obj0 = 0 ;
46545 :
46546 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_hashTableObj",&obj0)) SWIG_fail;
46547 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, SWIG_POINTER_DISOWN | 0 );
46548 1 : if (!SWIG_IsOK(res1)) {
46549 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_hashTableObj" "', argument " "1"" of type '" "hashTableObj *""'");
46550 : }
46551 1 : arg1 = (hashTableObj *)(argp1);
46552 : {
46553 : delete_hashTableObj(arg1); {
46554 1 : errorObj *ms_error = msGetErrorObj();
46555 :
46556 1 : switch(ms_error->code) {
46557 : case MS_NOERR:
46558 : break;
46559 0 : case MS_NOTFOUND:
46560 0 : msResetErrorList();
46561 0 : break;
46562 : case -1:
46563 : break;
46564 0 : case MS_IOERR:
46565 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46566 0 : _raise_ms_exception();
46567 0 : msResetErrorList();
46568 0 : return NULL;
46569 : }
46570 : default:
46571 0 : _raise_ms_exception();
46572 0 : msResetErrorList();
46573 0 : return NULL;
46574 : }
46575 :
46576 : }
46577 : }
46578 : resultobj = SWIG_Py_Void();
46579 1 : return resultobj;
46580 0 : fail:
46581 : return NULL;
46582 : }
46583 :
46584 :
46585 1 : SWIGINTERN PyObject *_wrap_hashTableObj_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46586 : PyObject *resultobj = 0;
46587 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46588 : char *arg2 = (char *) 0 ;
46589 : char *arg3 = (char *) 0 ;
46590 1 : void *argp1 = 0 ;
46591 : int res1 = 0 ;
46592 : int res2 ;
46593 1 : char *buf2 = 0 ;
46594 1 : int alloc2 = 0 ;
46595 : int res3 ;
46596 1 : char *buf3 = 0 ;
46597 1 : int alloc3 = 0 ;
46598 1 : PyObject * obj0 = 0 ;
46599 1 : PyObject * obj1 = 0 ;
46600 1 : PyObject * obj2 = 0 ;
46601 : int result;
46602 :
46603 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:hashTableObj_set",&obj0,&obj1,&obj2)) SWIG_fail;
46604 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46605 1 : if (!SWIG_IsOK(res1)) {
46606 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_set" "', argument " "1"" of type '" "hashTableObj *""'");
46607 : }
46608 1 : arg1 = (hashTableObj *)(argp1);
46609 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46610 1 : if (!SWIG_IsOK(res2)) {
46611 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_set" "', argument " "2"" of type '" "char *""'");
46612 : }
46613 1 : arg2 = (char *)(buf2);
46614 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
46615 1 : if (!SWIG_IsOK(res3)) {
46616 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "hashTableObj_set" "', argument " "3"" of type '" "char *""'");
46617 : }
46618 1 : arg3 = (char *)(buf3);
46619 : {
46620 : result = (int)hashTableObj_set(arg1,arg2,arg3); {
46621 1 : errorObj *ms_error = msGetErrorObj();
46622 :
46623 1 : switch(ms_error->code) {
46624 : case MS_NOERR:
46625 : break;
46626 0 : case MS_NOTFOUND:
46627 0 : msResetErrorList();
46628 0 : break;
46629 : case -1:
46630 : break;
46631 0 : case MS_IOERR:
46632 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46633 0 : _raise_ms_exception();
46634 0 : msResetErrorList();
46635 0 : return NULL;
46636 : }
46637 : default:
46638 0 : _raise_ms_exception();
46639 0 : msResetErrorList();
46640 0 : return NULL;
46641 : }
46642 :
46643 : }
46644 : }
46645 : resultobj = SWIG_From_int((int)(result));
46646 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46647 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
46648 : return resultobj;
46649 0 : fail:
46650 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46651 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
46652 : return NULL;
46653 : }
46654 :
46655 :
46656 1 : SWIGINTERN PyObject *_wrap_hashTableObj_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46657 : PyObject *resultobj = 0;
46658 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46659 : char *arg2 = (char *) 0 ;
46660 : char *arg3 = (char *) NULL ;
46661 1 : void *argp1 = 0 ;
46662 : int res1 = 0 ;
46663 : int res2 ;
46664 1 : char *buf2 = 0 ;
46665 1 : int alloc2 = 0 ;
46666 : int res3 ;
46667 1 : char *buf3 = 0 ;
46668 1 : int alloc3 = 0 ;
46669 1 : PyObject * obj0 = 0 ;
46670 1 : PyObject * obj1 = 0 ;
46671 1 : PyObject * obj2 = 0 ;
46672 : char *result = 0 ;
46673 :
46674 1 : if (!PyArg_ParseTuple(args,(char *)"OO|O:hashTableObj_get",&obj0,&obj1,&obj2)) SWIG_fail;
46675 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46676 1 : if (!SWIG_IsOK(res1)) {
46677 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_get" "', argument " "1"" of type '" "hashTableObj *""'");
46678 : }
46679 1 : arg1 = (hashTableObj *)(argp1);
46680 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46681 1 : if (!SWIG_IsOK(res2)) {
46682 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_get" "', argument " "2"" of type '" "char *""'");
46683 : }
46684 1 : arg2 = (char *)(buf2);
46685 1 : if (obj2) {
46686 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
46687 1 : if (!SWIG_IsOK(res3)) {
46688 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "hashTableObj_get" "', argument " "3"" of type '" "char *""'");
46689 : }
46690 1 : arg3 = (char *)(buf3);
46691 : }
46692 : {
46693 1 : result = (char *)hashTableObj_get(arg1,arg2,arg3); {
46694 1 : errorObj *ms_error = msGetErrorObj();
46695 :
46696 1 : switch(ms_error->code) {
46697 : case MS_NOERR:
46698 : break;
46699 0 : case MS_NOTFOUND:
46700 0 : msResetErrorList();
46701 0 : break;
46702 : case -1:
46703 : break;
46704 0 : case MS_IOERR:
46705 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46706 0 : _raise_ms_exception();
46707 0 : msResetErrorList();
46708 0 : return NULL;
46709 : }
46710 : default:
46711 0 : _raise_ms_exception();
46712 0 : msResetErrorList();
46713 0 : return NULL;
46714 : }
46715 :
46716 : }
46717 : }
46718 1 : resultobj = SWIG_FromCharPtr((const char *)result);
46719 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46720 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
46721 : return resultobj;
46722 0 : fail:
46723 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46724 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
46725 : return NULL;
46726 : }
46727 :
46728 :
46729 1 : SWIGINTERN PyObject *_wrap_hashTableObj_remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46730 : PyObject *resultobj = 0;
46731 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46732 : char *arg2 = (char *) 0 ;
46733 1 : void *argp1 = 0 ;
46734 : int res1 = 0 ;
46735 : int res2 ;
46736 1 : char *buf2 = 0 ;
46737 1 : int alloc2 = 0 ;
46738 1 : PyObject * obj0 = 0 ;
46739 1 : PyObject * obj1 = 0 ;
46740 : int result;
46741 :
46742 1 : if (!PyArg_ParseTuple(args,(char *)"OO:hashTableObj_remove",&obj0,&obj1)) SWIG_fail;
46743 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46744 1 : if (!SWIG_IsOK(res1)) {
46745 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_remove" "', argument " "1"" of type '" "hashTableObj *""'");
46746 : }
46747 1 : arg1 = (hashTableObj *)(argp1);
46748 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46749 1 : if (!SWIG_IsOK(res2)) {
46750 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_remove" "', argument " "2"" of type '" "char *""'");
46751 : }
46752 1 : arg2 = (char *)(buf2);
46753 : {
46754 : result = (int)hashTableObj_remove(arg1,arg2); {
46755 1 : errorObj *ms_error = msGetErrorObj();
46756 :
46757 1 : switch(ms_error->code) {
46758 : case MS_NOERR:
46759 : break;
46760 0 : case MS_NOTFOUND:
46761 0 : msResetErrorList();
46762 0 : break;
46763 : case -1:
46764 : break;
46765 0 : case MS_IOERR:
46766 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46767 0 : _raise_ms_exception();
46768 0 : msResetErrorList();
46769 0 : return NULL;
46770 : }
46771 : default:
46772 0 : _raise_ms_exception();
46773 0 : msResetErrorList();
46774 0 : return NULL;
46775 : }
46776 :
46777 : }
46778 : }
46779 : resultobj = SWIG_From_int((int)(result));
46780 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46781 : return resultobj;
46782 0 : fail:
46783 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46784 : return NULL;
46785 : }
46786 :
46787 :
46788 1 : SWIGINTERN PyObject *_wrap_hashTableObj_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46789 : PyObject *resultobj = 0;
46790 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46791 1 : void *argp1 = 0 ;
46792 : int res1 = 0 ;
46793 1 : PyObject * obj0 = 0 ;
46794 :
46795 1 : if (!PyArg_ParseTuple(args,(char *)"O:hashTableObj_clear",&obj0)) SWIG_fail;
46796 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46797 1 : if (!SWIG_IsOK(res1)) {
46798 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_clear" "', argument " "1"" of type '" "hashTableObj *""'");
46799 : }
46800 1 : arg1 = (hashTableObj *)(argp1);
46801 : {
46802 : hashTableObj_clear(arg1); {
46803 1 : errorObj *ms_error = msGetErrorObj();
46804 :
46805 1 : switch(ms_error->code) {
46806 : case MS_NOERR:
46807 : break;
46808 0 : case MS_NOTFOUND:
46809 0 : msResetErrorList();
46810 0 : break;
46811 : case -1:
46812 : break;
46813 0 : case MS_IOERR:
46814 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46815 0 : _raise_ms_exception();
46816 0 : msResetErrorList();
46817 0 : return NULL;
46818 : }
46819 : default:
46820 0 : _raise_ms_exception();
46821 0 : msResetErrorList();
46822 0 : return NULL;
46823 : }
46824 :
46825 : }
46826 : }
46827 : resultobj = SWIG_Py_Void();
46828 1 : return resultobj;
46829 0 : fail:
46830 : return NULL;
46831 : }
46832 :
46833 :
46834 1 : SWIGINTERN PyObject *_wrap_hashTableObj_nextKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46835 : PyObject *resultobj = 0;
46836 : hashTableObj *arg1 = (hashTableObj *) 0 ;
46837 : char *arg2 = (char *) NULL ;
46838 1 : void *argp1 = 0 ;
46839 : int res1 = 0 ;
46840 : int res2 ;
46841 1 : char *buf2 = 0 ;
46842 1 : int alloc2 = 0 ;
46843 1 : PyObject * obj0 = 0 ;
46844 1 : PyObject * obj1 = 0 ;
46845 : char *result = 0 ;
46846 :
46847 1 : if (!PyArg_ParseTuple(args,(char *)"O|O:hashTableObj_nextKey",&obj0,&obj1)) SWIG_fail;
46848 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_hashTableObj, 0 | 0 );
46849 1 : if (!SWIG_IsOK(res1)) {
46850 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "hashTableObj_nextKey" "', argument " "1"" of type '" "hashTableObj *""'");
46851 : }
46852 1 : arg1 = (hashTableObj *)(argp1);
46853 1 : if (obj1) {
46854 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46855 1 : if (!SWIG_IsOK(res2)) {
46856 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "hashTableObj_nextKey" "', argument " "2"" of type '" "char *""'");
46857 : }
46858 1 : arg2 = (char *)(buf2);
46859 : }
46860 : {
46861 : result = (char *)hashTableObj_nextKey(arg1,arg2); {
46862 1 : errorObj *ms_error = msGetErrorObj();
46863 :
46864 1 : switch(ms_error->code) {
46865 : case MS_NOERR:
46866 : break;
46867 0 : case MS_NOTFOUND:
46868 0 : msResetErrorList();
46869 0 : break;
46870 : case -1:
46871 : break;
46872 0 : case MS_IOERR:
46873 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
46874 0 : _raise_ms_exception();
46875 0 : msResetErrorList();
46876 0 : return NULL;
46877 : }
46878 : default:
46879 0 : _raise_ms_exception();
46880 0 : msResetErrorList();
46881 0 : return NULL;
46882 : }
46883 :
46884 : }
46885 : }
46886 1 : resultobj = SWIG_FromCharPtr((const char *)result);
46887 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46888 : return resultobj;
46889 0 : fail:
46890 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
46891 : return NULL;
46892 : }
46893 :
46894 :
46895 1 : SWIGINTERN PyObject *hashTableObj_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46896 : PyObject *obj;
46897 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
46898 1 : SWIG_TypeNewClientData(SWIGTYPE_p_hashTableObj, SWIG_NewClientData(obj));
46899 1 : return SWIG_Py_Void();
46900 : }
46901 :
46902 1 : SWIGINTERN PyObject *_wrap_OWSRequest_NumParams_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46903 : PyObject *resultobj = 0;
46904 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
46905 1 : void *argp1 = 0 ;
46906 : int res1 = 0 ;
46907 1 : PyObject * obj0 = 0 ;
46908 : int result;
46909 :
46910 1 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_NumParams_get",&obj0)) SWIG_fail;
46911 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
46912 1 : if (!SWIG_IsOK(res1)) {
46913 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_NumParams_get" "', argument " "1"" of type '" "cgiRequestObj *""'");
46914 : }
46915 1 : arg1 = (cgiRequestObj *)(argp1);
46916 1 : result = (int) ((arg1)->NumParams);
46917 : resultobj = SWIG_From_int((int)(result));
46918 1 : return resultobj;
46919 0 : fail:
46920 : return NULL;
46921 : }
46922 :
46923 :
46924 1 : SWIGINTERN PyObject *_wrap_OWSRequest_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46925 : PyObject *resultobj = 0;
46926 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
46927 : enum MS_REQUEST_TYPE arg2 ;
46928 1 : void *argp1 = 0 ;
46929 : int res1 = 0 ;
46930 : int val2 ;
46931 : int ecode2 = 0 ;
46932 1 : PyObject * obj0 = 0 ;
46933 1 : PyObject * obj1 = 0 ;
46934 :
46935 1 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_type_set",&obj0,&obj1)) SWIG_fail;
46936 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
46937 1 : if (!SWIG_IsOK(res1)) {
46938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_type_set" "', argument " "1"" of type '" "cgiRequestObj *""'");
46939 : }
46940 1 : arg1 = (cgiRequestObj *)(argp1);
46941 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
46942 1 : if (!SWIG_IsOK(ecode2)) {
46943 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_type_set" "', argument " "2"" of type '" "enum MS_REQUEST_TYPE""'");
46944 : }
46945 1 : arg2 = (enum MS_REQUEST_TYPE)(val2);
46946 1 : if (arg1) (arg1)->type = arg2;
46947 : resultobj = SWIG_Py_Void();
46948 1 : return resultobj;
46949 0 : fail:
46950 : return NULL;
46951 : }
46952 :
46953 :
46954 0 : SWIGINTERN PyObject *_wrap_OWSRequest_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46955 : PyObject *resultobj = 0;
46956 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
46957 0 : void *argp1 = 0 ;
46958 : int res1 = 0 ;
46959 0 : PyObject * obj0 = 0 ;
46960 : enum MS_REQUEST_TYPE result;
46961 :
46962 0 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_type_get",&obj0)) SWIG_fail;
46963 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
46964 0 : if (!SWIG_IsOK(res1)) {
46965 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_type_get" "', argument " "1"" of type '" "cgiRequestObj *""'");
46966 : }
46967 0 : arg1 = (cgiRequestObj *)(argp1);
46968 0 : result = (enum MS_REQUEST_TYPE) ((arg1)->type);
46969 0 : resultobj = SWIG_From_int((int)(result));
46970 0 : return resultobj;
46971 0 : fail:
46972 : return NULL;
46973 : }
46974 :
46975 :
46976 0 : SWIGINTERN PyObject *_wrap_OWSRequest_contenttype_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46977 : PyObject *resultobj = 0;
46978 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
46979 : char *arg2 = (char *) 0 ;
46980 0 : void *argp1 = 0 ;
46981 : int res1 = 0 ;
46982 : int res2 ;
46983 0 : char *buf2 = 0 ;
46984 0 : int alloc2 = 0 ;
46985 0 : PyObject * obj0 = 0 ;
46986 0 : PyObject * obj1 = 0 ;
46987 :
46988 0 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_contenttype_set",&obj0,&obj1)) SWIG_fail;
46989 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
46990 0 : if (!SWIG_IsOK(res1)) {
46991 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_contenttype_set" "', argument " "1"" of type '" "cgiRequestObj *""'");
46992 : }
46993 0 : arg1 = (cgiRequestObj *)(argp1);
46994 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
46995 0 : if (!SWIG_IsOK(res2)) {
46996 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_contenttype_set" "', argument " "2"" of type '" "char *""'");
46997 : }
46998 0 : arg2 = (char *)(buf2);
46999 : {
47000 0 : if (arg1->contenttype) free((char*)arg1->contenttype);
47001 0 : if (arg2) {
47002 0 : arg1->contenttype = (char *) malloc(strlen(arg2)+1);
47003 : strcpy((char*)arg1->contenttype,arg2);
47004 : } else {
47005 0 : arg1->contenttype = 0;
47006 : }
47007 : }
47008 : resultobj = SWIG_Py_Void();
47009 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47010 : return resultobj;
47011 0 : fail:
47012 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47013 : return NULL;
47014 : }
47015 :
47016 :
47017 0 : SWIGINTERN PyObject *_wrap_OWSRequest_contenttype_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47018 : PyObject *resultobj = 0;
47019 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47020 0 : void *argp1 = 0 ;
47021 : int res1 = 0 ;
47022 0 : PyObject * obj0 = 0 ;
47023 : char *result = 0 ;
47024 :
47025 0 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_contenttype_get",&obj0)) SWIG_fail;
47026 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47027 0 : if (!SWIG_IsOK(res1)) {
47028 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_contenttype_get" "', argument " "1"" of type '" "cgiRequestObj *""'");
47029 : }
47030 0 : arg1 = (cgiRequestObj *)(argp1);
47031 0 : result = (char *) ((arg1)->contenttype);
47032 0 : resultobj = SWIG_FromCharPtr((const char *)result);
47033 0 : return resultobj;
47034 0 : fail:
47035 : return NULL;
47036 : }
47037 :
47038 :
47039 0 : SWIGINTERN PyObject *_wrap_OWSRequest_postrequest_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47040 : PyObject *resultobj = 0;
47041 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47042 : char *arg2 = (char *) 0 ;
47043 0 : void *argp1 = 0 ;
47044 : int res1 = 0 ;
47045 : int res2 ;
47046 0 : char *buf2 = 0 ;
47047 0 : int alloc2 = 0 ;
47048 0 : PyObject * obj0 = 0 ;
47049 0 : PyObject * obj1 = 0 ;
47050 :
47051 0 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_postrequest_set",&obj0,&obj1)) SWIG_fail;
47052 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47053 0 : if (!SWIG_IsOK(res1)) {
47054 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_postrequest_set" "', argument " "1"" of type '" "cgiRequestObj *""'");
47055 : }
47056 0 : arg1 = (cgiRequestObj *)(argp1);
47057 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47058 0 : if (!SWIG_IsOK(res2)) {
47059 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_postrequest_set" "', argument " "2"" of type '" "char *""'");
47060 : }
47061 0 : arg2 = (char *)(buf2);
47062 : {
47063 0 : if (arg1->postrequest) free((char*)arg1->postrequest);
47064 0 : if (arg2) {
47065 0 : arg1->postrequest = (char *) malloc(strlen(arg2)+1);
47066 : strcpy((char*)arg1->postrequest,arg2);
47067 : } else {
47068 0 : arg1->postrequest = 0;
47069 : }
47070 : }
47071 : resultobj = SWIG_Py_Void();
47072 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47073 : return resultobj;
47074 0 : fail:
47075 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47076 : return NULL;
47077 : }
47078 :
47079 :
47080 0 : SWIGINTERN PyObject *_wrap_OWSRequest_postrequest_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47081 : PyObject *resultobj = 0;
47082 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47083 0 : void *argp1 = 0 ;
47084 : int res1 = 0 ;
47085 0 : PyObject * obj0 = 0 ;
47086 : char *result = 0 ;
47087 :
47088 0 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_postrequest_get",&obj0)) SWIG_fail;
47089 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47090 0 : if (!SWIG_IsOK(res1)) {
47091 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_postrequest_get" "', argument " "1"" of type '" "cgiRequestObj *""'");
47092 : }
47093 0 : arg1 = (cgiRequestObj *)(argp1);
47094 0 : result = (char *) ((arg1)->postrequest);
47095 0 : resultobj = SWIG_FromCharPtr((const char *)result);
47096 0 : return resultobj;
47097 0 : fail:
47098 : return NULL;
47099 : }
47100 :
47101 :
47102 0 : SWIGINTERN PyObject *_wrap_OWSRequest_httpcookiedata_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47103 : PyObject *resultobj = 0;
47104 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47105 : char *arg2 = (char *) 0 ;
47106 0 : void *argp1 = 0 ;
47107 : int res1 = 0 ;
47108 : int res2 ;
47109 0 : char *buf2 = 0 ;
47110 0 : int alloc2 = 0 ;
47111 0 : PyObject * obj0 = 0 ;
47112 0 : PyObject * obj1 = 0 ;
47113 :
47114 0 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_httpcookiedata_set",&obj0,&obj1)) SWIG_fail;
47115 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47116 0 : if (!SWIG_IsOK(res1)) {
47117 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_httpcookiedata_set" "', argument " "1"" of type '" "cgiRequestObj *""'");
47118 : }
47119 0 : arg1 = (cgiRequestObj *)(argp1);
47120 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47121 0 : if (!SWIG_IsOK(res2)) {
47122 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_httpcookiedata_set" "', argument " "2"" of type '" "char *""'");
47123 : }
47124 0 : arg2 = (char *)(buf2);
47125 : {
47126 0 : if (arg1->httpcookiedata) free((char*)arg1->httpcookiedata);
47127 0 : if (arg2) {
47128 0 : arg1->httpcookiedata = (char *) malloc(strlen(arg2)+1);
47129 : strcpy((char*)arg1->httpcookiedata,arg2);
47130 : } else {
47131 0 : arg1->httpcookiedata = 0;
47132 : }
47133 : }
47134 : resultobj = SWIG_Py_Void();
47135 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47136 : return resultobj;
47137 0 : fail:
47138 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47139 : return NULL;
47140 : }
47141 :
47142 :
47143 0 : SWIGINTERN PyObject *_wrap_OWSRequest_httpcookiedata_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47144 : PyObject *resultobj = 0;
47145 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47146 0 : void *argp1 = 0 ;
47147 : int res1 = 0 ;
47148 0 : PyObject * obj0 = 0 ;
47149 : char *result = 0 ;
47150 :
47151 0 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_httpcookiedata_get",&obj0)) SWIG_fail;
47152 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47153 0 : if (!SWIG_IsOK(res1)) {
47154 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_httpcookiedata_get" "', argument " "1"" of type '" "cgiRequestObj *""'");
47155 : }
47156 0 : arg1 = (cgiRequestObj *)(argp1);
47157 0 : result = (char *) ((arg1)->httpcookiedata);
47158 0 : resultobj = SWIG_FromCharPtr((const char *)result);
47159 0 : return resultobj;
47160 0 : fail:
47161 : return NULL;
47162 : }
47163 :
47164 :
47165 1 : SWIGINTERN PyObject *_wrap_new_OWSRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47166 : PyObject *resultobj = 0;
47167 : cgiRequestObj *result = 0 ;
47168 :
47169 1 : if (!PyArg_ParseTuple(args,(char *)":new_OWSRequest")) SWIG_fail;
47170 : {
47171 1 : result = (cgiRequestObj *)new_cgiRequestObj(); {
47172 1 : errorObj *ms_error = msGetErrorObj();
47173 :
47174 1 : switch(ms_error->code) {
47175 : case MS_NOERR:
47176 : break;
47177 0 : case MS_NOTFOUND:
47178 0 : msResetErrorList();
47179 0 : break;
47180 : case -1:
47181 : break;
47182 0 : case MS_IOERR:
47183 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47184 0 : _raise_ms_exception();
47185 0 : msResetErrorList();
47186 0 : return NULL;
47187 : }
47188 : default:
47189 0 : _raise_ms_exception();
47190 0 : msResetErrorList();
47191 0 : return NULL;
47192 : }
47193 :
47194 : }
47195 : }
47196 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_cgiRequestObj, SWIG_POINTER_NEW | 0 );
47197 1 : return resultobj;
47198 1 : fail:
47199 : return NULL;
47200 : }
47201 :
47202 :
47203 1 : SWIGINTERN PyObject *_wrap_delete_OWSRequest(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47204 : PyObject *resultobj = 0;
47205 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47206 1 : void *argp1 = 0 ;
47207 : int res1 = 0 ;
47208 1 : PyObject * obj0 = 0 ;
47209 :
47210 1 : if (!PyArg_ParseTuple(args,(char *)"O:delete_OWSRequest",&obj0)) SWIG_fail;
47211 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, SWIG_POINTER_DISOWN | 0 );
47212 1 : if (!SWIG_IsOK(res1)) {
47213 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_OWSRequest" "', argument " "1"" of type '" "cgiRequestObj *""'");
47214 : }
47215 1 : arg1 = (cgiRequestObj *)(argp1);
47216 : {
47217 : delete_cgiRequestObj(arg1); {
47218 1 : errorObj *ms_error = msGetErrorObj();
47219 :
47220 1 : switch(ms_error->code) {
47221 : case MS_NOERR:
47222 : break;
47223 0 : case MS_NOTFOUND:
47224 0 : msResetErrorList();
47225 0 : break;
47226 : case -1:
47227 : break;
47228 0 : case MS_IOERR:
47229 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47230 0 : _raise_ms_exception();
47231 0 : msResetErrorList();
47232 0 : return NULL;
47233 : }
47234 : default:
47235 0 : _raise_ms_exception();
47236 0 : msResetErrorList();
47237 0 : return NULL;
47238 : }
47239 :
47240 : }
47241 : }
47242 : resultobj = SWIG_Py_Void();
47243 1 : return resultobj;
47244 0 : fail:
47245 : return NULL;
47246 : }
47247 :
47248 :
47249 0 : SWIGINTERN PyObject *_wrap_OWSRequest_loadParams(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47250 : PyObject *resultobj = 0;
47251 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47252 0 : void *argp1 = 0 ;
47253 : int res1 = 0 ;
47254 0 : PyObject * obj0 = 0 ;
47255 : int result;
47256 :
47257 0 : if (!PyArg_ParseTuple(args,(char *)"O:OWSRequest_loadParams",&obj0)) SWIG_fail;
47258 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47259 0 : if (!SWIG_IsOK(res1)) {
47260 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_loadParams" "', argument " "1"" of type '" "cgiRequestObj *""'");
47261 : }
47262 0 : arg1 = (cgiRequestObj *)(argp1);
47263 : {
47264 : result = (int)cgiRequestObj_loadParams(arg1); {
47265 0 : errorObj *ms_error = msGetErrorObj();
47266 :
47267 0 : switch(ms_error->code) {
47268 : case MS_NOERR:
47269 : break;
47270 0 : case MS_NOTFOUND:
47271 0 : msResetErrorList();
47272 0 : break;
47273 : case -1:
47274 : break;
47275 0 : case MS_IOERR:
47276 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47277 0 : _raise_ms_exception();
47278 0 : msResetErrorList();
47279 0 : return NULL;
47280 : }
47281 : default:
47282 0 : _raise_ms_exception();
47283 0 : msResetErrorList();
47284 0 : return NULL;
47285 : }
47286 :
47287 : }
47288 : }
47289 : resultobj = SWIG_From_int((int)(result));
47290 0 : return resultobj;
47291 0 : fail:
47292 : return NULL;
47293 : }
47294 :
47295 :
47296 1 : SWIGINTERN PyObject *_wrap_OWSRequest_loadParamsFromURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47297 : PyObject *resultobj = 0;
47298 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47299 : char *arg2 = (char *) 0 ;
47300 1 : void *argp1 = 0 ;
47301 : int res1 = 0 ;
47302 : int res2 ;
47303 1 : char *buf2 = 0 ;
47304 1 : int alloc2 = 0 ;
47305 1 : PyObject * obj0 = 0 ;
47306 1 : PyObject * obj1 = 0 ;
47307 : int result;
47308 :
47309 1 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_loadParamsFromURL",&obj0,&obj1)) SWIG_fail;
47310 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47311 1 : if (!SWIG_IsOK(res1)) {
47312 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_loadParamsFromURL" "', argument " "1"" of type '" "cgiRequestObj *""'");
47313 : }
47314 1 : arg1 = (cgiRequestObj *)(argp1);
47315 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47316 1 : if (!SWIG_IsOK(res2)) {
47317 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_loadParamsFromURL" "', argument " "2"" of type '" "char const *""'");
47318 : }
47319 1 : arg2 = (char *)(buf2);
47320 : {
47321 : result = (int)cgiRequestObj_loadParamsFromURL(arg1,(char const *)arg2); {
47322 1 : errorObj *ms_error = msGetErrorObj();
47323 :
47324 1 : switch(ms_error->code) {
47325 : case MS_NOERR:
47326 : break;
47327 0 : case MS_NOTFOUND:
47328 0 : msResetErrorList();
47329 0 : break;
47330 : case -1:
47331 : break;
47332 0 : case MS_IOERR:
47333 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47334 0 : _raise_ms_exception();
47335 0 : msResetErrorList();
47336 0 : return NULL;
47337 : }
47338 : default:
47339 0 : _raise_ms_exception();
47340 0 : msResetErrorList();
47341 0 : return NULL;
47342 : }
47343 :
47344 : }
47345 : }
47346 : resultobj = SWIG_From_int((int)(result));
47347 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47348 : return resultobj;
47349 0 : fail:
47350 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47351 : return NULL;
47352 : }
47353 :
47354 :
47355 1 : SWIGINTERN PyObject *_wrap_OWSRequest_setParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47356 : PyObject *resultobj = 0;
47357 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47358 : char *arg2 = (char *) 0 ;
47359 : char *arg3 = (char *) 0 ;
47360 1 : void *argp1 = 0 ;
47361 : int res1 = 0 ;
47362 : int res2 ;
47363 1 : char *buf2 = 0 ;
47364 1 : int alloc2 = 0 ;
47365 : int res3 ;
47366 1 : char *buf3 = 0 ;
47367 1 : int alloc3 = 0 ;
47368 1 : PyObject * obj0 = 0 ;
47369 1 : PyObject * obj1 = 0 ;
47370 1 : PyObject * obj2 = 0 ;
47371 :
47372 1 : if (!PyArg_ParseTuple(args,(char *)"OOO:OWSRequest_setParameter",&obj0,&obj1,&obj2)) SWIG_fail;
47373 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47374 1 : if (!SWIG_IsOK(res1)) {
47375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_setParameter" "', argument " "1"" of type '" "cgiRequestObj *""'");
47376 : }
47377 1 : arg1 = (cgiRequestObj *)(argp1);
47378 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47379 1 : if (!SWIG_IsOK(res2)) {
47380 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_setParameter" "', argument " "2"" of type '" "char *""'");
47381 : }
47382 1 : arg2 = (char *)(buf2);
47383 1 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
47384 1 : if (!SWIG_IsOK(res3)) {
47385 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OWSRequest_setParameter" "', argument " "3"" of type '" "char *""'");
47386 : }
47387 1 : arg3 = (char *)(buf3);
47388 : {
47389 1 : cgiRequestObj_setParameter(arg1,arg2,arg3); {
47390 1 : errorObj *ms_error = msGetErrorObj();
47391 :
47392 1 : switch(ms_error->code) {
47393 : case MS_NOERR:
47394 : break;
47395 0 : case MS_NOTFOUND:
47396 0 : msResetErrorList();
47397 0 : break;
47398 : case -1:
47399 : break;
47400 0 : case MS_IOERR:
47401 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47402 0 : _raise_ms_exception();
47403 0 : msResetErrorList();
47404 0 : return NULL;
47405 : }
47406 : default:
47407 0 : _raise_ms_exception();
47408 0 : msResetErrorList();
47409 0 : return NULL;
47410 : }
47411 :
47412 : }
47413 : }
47414 : resultobj = SWIG_Py_Void();
47415 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47416 1 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
47417 : return resultobj;
47418 0 : fail:
47419 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47420 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
47421 : return NULL;
47422 : }
47423 :
47424 :
47425 0 : SWIGINTERN PyObject *_wrap_OWSRequest_addParameter(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47426 : PyObject *resultobj = 0;
47427 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47428 : char *arg2 = (char *) 0 ;
47429 : char *arg3 = (char *) 0 ;
47430 0 : void *argp1 = 0 ;
47431 : int res1 = 0 ;
47432 : int res2 ;
47433 0 : char *buf2 = 0 ;
47434 0 : int alloc2 = 0 ;
47435 : int res3 ;
47436 0 : char *buf3 = 0 ;
47437 0 : int alloc3 = 0 ;
47438 0 : PyObject * obj0 = 0 ;
47439 0 : PyObject * obj1 = 0 ;
47440 0 : PyObject * obj2 = 0 ;
47441 :
47442 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:OWSRequest_addParameter",&obj0,&obj1,&obj2)) SWIG_fail;
47443 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47444 0 : if (!SWIG_IsOK(res1)) {
47445 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_addParameter" "', argument " "1"" of type '" "cgiRequestObj *""'");
47446 : }
47447 0 : arg1 = (cgiRequestObj *)(argp1);
47448 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47449 0 : if (!SWIG_IsOK(res2)) {
47450 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_addParameter" "', argument " "2"" of type '" "char *""'");
47451 : }
47452 0 : arg2 = (char *)(buf2);
47453 0 : res3 = SWIG_AsCharPtrAndSize(obj2, &buf3, NULL, &alloc3);
47454 0 : if (!SWIG_IsOK(res3)) {
47455 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "OWSRequest_addParameter" "', argument " "3"" of type '" "char *""'");
47456 : }
47457 0 : arg3 = (char *)(buf3);
47458 : {
47459 0 : cgiRequestObj_addParameter(arg1,arg2,arg3); {
47460 0 : errorObj *ms_error = msGetErrorObj();
47461 :
47462 0 : switch(ms_error->code) {
47463 : case MS_NOERR:
47464 : break;
47465 0 : case MS_NOTFOUND:
47466 0 : msResetErrorList();
47467 0 : break;
47468 : case -1:
47469 : break;
47470 0 : case MS_IOERR:
47471 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47472 0 : _raise_ms_exception();
47473 0 : msResetErrorList();
47474 0 : return NULL;
47475 : }
47476 : default:
47477 0 : _raise_ms_exception();
47478 0 : msResetErrorList();
47479 0 : return NULL;
47480 : }
47481 :
47482 : }
47483 : }
47484 : resultobj = SWIG_Py_Void();
47485 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47486 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
47487 : return resultobj;
47488 0 : fail:
47489 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47490 0 : if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
47491 : return NULL;
47492 : }
47493 :
47494 :
47495 1 : SWIGINTERN PyObject *_wrap_OWSRequest_getName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47496 : PyObject *resultobj = 0;
47497 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47498 : int arg2 ;
47499 1 : void *argp1 = 0 ;
47500 : int res1 = 0 ;
47501 : int val2 ;
47502 : int ecode2 = 0 ;
47503 1 : PyObject * obj0 = 0 ;
47504 1 : PyObject * obj1 = 0 ;
47505 : char *result = 0 ;
47506 :
47507 1 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getName",&obj0,&obj1)) SWIG_fail;
47508 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47509 1 : if (!SWIG_IsOK(res1)) {
47510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getName" "', argument " "1"" of type '" "cgiRequestObj *""'");
47511 : }
47512 1 : arg1 = (cgiRequestObj *)(argp1);
47513 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
47514 1 : if (!SWIG_IsOK(ecode2)) {
47515 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_getName" "', argument " "2"" of type '" "int""'");
47516 : }
47517 : arg2 = (int)(val2);
47518 : {
47519 1 : result = (char *)cgiRequestObj_getName(arg1,arg2); {
47520 1 : errorObj *ms_error = msGetErrorObj();
47521 :
47522 1 : switch(ms_error->code) {
47523 : case MS_NOERR:
47524 : break;
47525 0 : case MS_NOTFOUND:
47526 0 : msResetErrorList();
47527 0 : break;
47528 : case -1:
47529 : break;
47530 0 : case MS_IOERR:
47531 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47532 0 : _raise_ms_exception();
47533 0 : msResetErrorList();
47534 0 : return NULL;
47535 : }
47536 : default:
47537 0 : _raise_ms_exception();
47538 0 : msResetErrorList();
47539 0 : return NULL;
47540 : }
47541 :
47542 : }
47543 : }
47544 1 : resultobj = SWIG_FromCharPtr((const char *)result);
47545 1 : return resultobj;
47546 0 : fail:
47547 : return NULL;
47548 : }
47549 :
47550 :
47551 1 : SWIGINTERN PyObject *_wrap_OWSRequest_getValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47552 : PyObject *resultobj = 0;
47553 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47554 : int arg2 ;
47555 1 : void *argp1 = 0 ;
47556 : int res1 = 0 ;
47557 : int val2 ;
47558 : int ecode2 = 0 ;
47559 1 : PyObject * obj0 = 0 ;
47560 1 : PyObject * obj1 = 0 ;
47561 : char *result = 0 ;
47562 :
47563 1 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getValue",&obj0,&obj1)) SWIG_fail;
47564 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47565 1 : if (!SWIG_IsOK(res1)) {
47566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getValue" "', argument " "1"" of type '" "cgiRequestObj *""'");
47567 : }
47568 1 : arg1 = (cgiRequestObj *)(argp1);
47569 1 : ecode2 = SWIG_AsVal_int(obj1, &val2);
47570 1 : if (!SWIG_IsOK(ecode2)) {
47571 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "OWSRequest_getValue" "', argument " "2"" of type '" "int""'");
47572 : }
47573 : arg2 = (int)(val2);
47574 : {
47575 1 : result = (char *)cgiRequestObj_getValue(arg1,arg2); {
47576 1 : errorObj *ms_error = msGetErrorObj();
47577 :
47578 1 : switch(ms_error->code) {
47579 : case MS_NOERR:
47580 : break;
47581 0 : case MS_NOTFOUND:
47582 0 : msResetErrorList();
47583 0 : break;
47584 : case -1:
47585 : break;
47586 0 : case MS_IOERR:
47587 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47588 0 : _raise_ms_exception();
47589 0 : msResetErrorList();
47590 0 : return NULL;
47591 : }
47592 : default:
47593 0 : _raise_ms_exception();
47594 0 : msResetErrorList();
47595 0 : return NULL;
47596 : }
47597 :
47598 : }
47599 : }
47600 1 : resultobj = SWIG_FromCharPtr((const char *)result);
47601 1 : return resultobj;
47602 0 : fail:
47603 : return NULL;
47604 : }
47605 :
47606 :
47607 1 : SWIGINTERN PyObject *_wrap_OWSRequest_getValueByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47608 : PyObject *resultobj = 0;
47609 : cgiRequestObj *arg1 = (cgiRequestObj *) 0 ;
47610 : char *arg2 = (char *) 0 ;
47611 1 : void *argp1 = 0 ;
47612 : int res1 = 0 ;
47613 : int res2 ;
47614 1 : char *buf2 = 0 ;
47615 1 : int alloc2 = 0 ;
47616 1 : PyObject * obj0 = 0 ;
47617 1 : PyObject * obj1 = 0 ;
47618 : char *result = 0 ;
47619 :
47620 1 : if (!PyArg_ParseTuple(args,(char *)"OO:OWSRequest_getValueByName",&obj0,&obj1)) SWIG_fail;
47621 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_cgiRequestObj, 0 | 0 );
47622 1 : if (!SWIG_IsOK(res1)) {
47623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OWSRequest_getValueByName" "', argument " "1"" of type '" "cgiRequestObj *""'");
47624 : }
47625 1 : arg1 = (cgiRequestObj *)(argp1);
47626 1 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
47627 1 : if (!SWIG_IsOK(res2)) {
47628 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "OWSRequest_getValueByName" "', argument " "2"" of type '" "char const *""'");
47629 : }
47630 1 : arg2 = (char *)(buf2);
47631 : {
47632 1 : result = (char *)cgiRequestObj_getValueByName(arg1,(char const *)arg2); {
47633 1 : errorObj *ms_error = msGetErrorObj();
47634 :
47635 1 : switch(ms_error->code) {
47636 : case MS_NOERR:
47637 : break;
47638 0 : case MS_NOTFOUND:
47639 0 : msResetErrorList();
47640 0 : break;
47641 : case -1:
47642 : break;
47643 0 : case MS_IOERR:
47644 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47645 0 : _raise_ms_exception();
47646 0 : msResetErrorList();
47647 0 : return NULL;
47648 : }
47649 : default:
47650 0 : _raise_ms_exception();
47651 0 : msResetErrorList();
47652 0 : return NULL;
47653 : }
47654 :
47655 : }
47656 : }
47657 1 : resultobj = SWIG_FromCharPtr((const char *)result);
47658 1 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47659 : return resultobj;
47660 0 : fail:
47661 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
47662 : return NULL;
47663 : }
47664 :
47665 :
47666 1 : SWIGINTERN PyObject *OWSRequest_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47667 : PyObject *obj;
47668 1 : if (!PyArg_ParseTuple(args,(char *)"O:swigregister", &obj)) return NULL;
47669 1 : SWIG_TypeNewClientData(SWIGTYPE_p_cgiRequestObj, SWIG_NewClientData(obj));
47670 1 : return SWIG_Py_Void();
47671 : }
47672 :
47673 0 : SWIGINTERN PyObject *_wrap_msConnPoolCloseUnreferenced(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47674 : PyObject *resultobj = 0;
47675 :
47676 0 : if (!PyArg_ParseTuple(args,(char *)":msConnPoolCloseUnreferenced")) SWIG_fail;
47677 : {
47678 0 : msConnPoolCloseUnreferenced(); {
47679 0 : errorObj *ms_error = msGetErrorObj();
47680 :
47681 0 : switch(ms_error->code) {
47682 : case MS_NOERR:
47683 : break;
47684 0 : case MS_NOTFOUND:
47685 0 : msResetErrorList();
47686 0 : break;
47687 : case -1:
47688 : break;
47689 0 : case MS_IOERR:
47690 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47691 0 : _raise_ms_exception();
47692 0 : msResetErrorList();
47693 0 : return NULL;
47694 : }
47695 : default:
47696 0 : _raise_ms_exception();
47697 0 : msResetErrorList();
47698 0 : return NULL;
47699 : }
47700 :
47701 : }
47702 : }
47703 : resultobj = SWIG_Py_Void();
47704 0 : return resultobj;
47705 0 : fail:
47706 : return NULL;
47707 : }
47708 :
47709 :
47710 0 : SWIGINTERN PyObject *_wrap_msIO_resetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47711 : PyObject *resultobj = 0;
47712 :
47713 0 : if (!PyArg_ParseTuple(args,(char *)":msIO_resetHandlers")) SWIG_fail;
47714 : {
47715 0 : msIO_resetHandlers(); {
47716 0 : errorObj *ms_error = msGetErrorObj();
47717 :
47718 0 : switch(ms_error->code) {
47719 : case MS_NOERR:
47720 : break;
47721 0 : case MS_NOTFOUND:
47722 0 : msResetErrorList();
47723 0 : break;
47724 : case -1:
47725 : break;
47726 0 : case MS_IOERR:
47727 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47728 0 : _raise_ms_exception();
47729 0 : msResetErrorList();
47730 0 : return NULL;
47731 : }
47732 : default:
47733 0 : _raise_ms_exception();
47734 0 : msResetErrorList();
47735 0 : return NULL;
47736 : }
47737 :
47738 : }
47739 : }
47740 : resultobj = SWIG_Py_Void();
47741 0 : return resultobj;
47742 0 : fail:
47743 : return NULL;
47744 : }
47745 :
47746 :
47747 1 : SWIGINTERN PyObject *_wrap_msIO_installStdoutToBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47748 : PyObject *resultobj = 0;
47749 :
47750 1 : if (!PyArg_ParseTuple(args,(char *)":msIO_installStdoutToBuffer")) SWIG_fail;
47751 : {
47752 1 : msIO_installStdoutToBuffer(); {
47753 1 : errorObj *ms_error = msGetErrorObj();
47754 :
47755 1 : switch(ms_error->code) {
47756 : case MS_NOERR:
47757 : break;
47758 0 : case MS_NOTFOUND:
47759 0 : msResetErrorList();
47760 0 : break;
47761 : case -1:
47762 : break;
47763 0 : case MS_IOERR:
47764 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47765 0 : _raise_ms_exception();
47766 0 : msResetErrorList();
47767 0 : return NULL;
47768 : }
47769 : default:
47770 0 : _raise_ms_exception();
47771 0 : msResetErrorList();
47772 0 : return NULL;
47773 : }
47774 :
47775 : }
47776 : }
47777 : resultobj = SWIG_Py_Void();
47778 1 : return resultobj;
47779 1 : fail:
47780 : return NULL;
47781 : }
47782 :
47783 :
47784 0 : SWIGINTERN PyObject *_wrap_msIO_installStdinFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47785 : PyObject *resultobj = 0;
47786 :
47787 0 : if (!PyArg_ParseTuple(args,(char *)":msIO_installStdinFromBuffer")) SWIG_fail;
47788 : {
47789 0 : msIO_installStdinFromBuffer(); {
47790 0 : errorObj *ms_error = msGetErrorObj();
47791 :
47792 0 : switch(ms_error->code) {
47793 : case MS_NOERR:
47794 : break;
47795 0 : case MS_NOTFOUND:
47796 0 : msResetErrorList();
47797 0 : break;
47798 : case -1:
47799 : break;
47800 0 : case MS_IOERR:
47801 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47802 0 : _raise_ms_exception();
47803 0 : msResetErrorList();
47804 0 : return NULL;
47805 : }
47806 : default:
47807 0 : _raise_ms_exception();
47808 0 : msResetErrorList();
47809 0 : return NULL;
47810 : }
47811 :
47812 : }
47813 : }
47814 : resultobj = SWIG_Py_Void();
47815 0 : return resultobj;
47816 0 : fail:
47817 : return NULL;
47818 : }
47819 :
47820 :
47821 1 : SWIGINTERN PyObject *_wrap_msIO_stripStdoutBufferContentType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47822 : PyObject *resultobj = 0;
47823 : char *result = 0 ;
47824 :
47825 1 : if (!PyArg_ParseTuple(args,(char *)":msIO_stripStdoutBufferContentType")) SWIG_fail;
47826 : {
47827 1 : result = (char *)msIO_stripStdoutBufferContentType(); {
47828 1 : errorObj *ms_error = msGetErrorObj();
47829 :
47830 1 : switch(ms_error->code) {
47831 : case MS_NOERR:
47832 : break;
47833 0 : case MS_NOTFOUND:
47834 0 : msResetErrorList();
47835 0 : break;
47836 : case -1:
47837 : break;
47838 0 : case MS_IOERR:
47839 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47840 0 : _raise_ms_exception();
47841 0 : msResetErrorList();
47842 0 : return NULL;
47843 : }
47844 : default:
47845 0 : _raise_ms_exception();
47846 0 : msResetErrorList();
47847 0 : return NULL;
47848 : }
47849 :
47850 : }
47851 : }
47852 1 : resultobj = SWIG_FromCharPtr((const char *)result);
47853 1 : free((char*)result);
47854 1 : return resultobj;
47855 1 : fail:
47856 : return NULL;
47857 : }
47858 :
47859 :
47860 1 : SWIGINTERN PyObject *_wrap_msIO_stripStdoutBufferContentHeaders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47861 : PyObject *resultobj = 0;
47862 :
47863 1 : if (!PyArg_ParseTuple(args,(char *)":msIO_stripStdoutBufferContentHeaders")) SWIG_fail;
47864 : {
47865 1 : msIO_stripStdoutBufferContentHeaders(); {
47866 1 : errorObj *ms_error = msGetErrorObj();
47867 :
47868 1 : switch(ms_error->code) {
47869 : case MS_NOERR:
47870 : break;
47871 0 : case MS_NOTFOUND:
47872 0 : msResetErrorList();
47873 0 : break;
47874 : case -1:
47875 : break;
47876 0 : case MS_IOERR:
47877 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47878 0 : _raise_ms_exception();
47879 0 : msResetErrorList();
47880 0 : return NULL;
47881 : }
47882 : default:
47883 0 : _raise_ms_exception();
47884 0 : msResetErrorList();
47885 0 : return NULL;
47886 : }
47887 :
47888 : }
47889 : }
47890 : resultobj = SWIG_Py_Void();
47891 1 : return resultobj;
47892 1 : fail:
47893 : return NULL;
47894 : }
47895 :
47896 :
47897 0 : SWIGINTERN PyObject *_wrap_msIO_getStdoutBufferString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47898 : PyObject *resultobj = 0;
47899 : char *result = 0 ;
47900 :
47901 0 : if (!PyArg_ParseTuple(args,(char *)":msIO_getStdoutBufferString")) SWIG_fail;
47902 : {
47903 0 : result = (char *)msIO_getStdoutBufferString(); {
47904 0 : errorObj *ms_error = msGetErrorObj();
47905 :
47906 0 : switch(ms_error->code) {
47907 : case MS_NOERR:
47908 : break;
47909 0 : case MS_NOTFOUND:
47910 0 : msResetErrorList();
47911 0 : break;
47912 : case -1:
47913 : break;
47914 0 : case MS_IOERR:
47915 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47916 0 : _raise_ms_exception();
47917 0 : msResetErrorList();
47918 0 : return NULL;
47919 : }
47920 : default:
47921 0 : _raise_ms_exception();
47922 0 : msResetErrorList();
47923 0 : return NULL;
47924 : }
47925 :
47926 : }
47927 : }
47928 0 : resultobj = SWIG_FromCharPtr((const char *)result);
47929 0 : return resultobj;
47930 0 : fail:
47931 : return NULL;
47932 : }
47933 :
47934 :
47935 1 : SWIGINTERN PyObject *_wrap_msIO_getStdoutBufferBytes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47936 : PyObject *resultobj = 0;
47937 : gdBuffer result;
47938 :
47939 1 : if (!PyArg_ParseTuple(args,(char *)":msIO_getStdoutBufferBytes")) SWIG_fail;
47940 : {
47941 1 : result = msIO_getStdoutBufferBytes(); {
47942 1 : errorObj *ms_error = msGetErrorObj();
47943 :
47944 1 : switch(ms_error->code) {
47945 : case MS_NOERR:
47946 : break;
47947 0 : case MS_NOTFOUND:
47948 0 : msResetErrorList();
47949 0 : break;
47950 : case -1:
47951 : break;
47952 0 : case MS_IOERR:
47953 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47954 0 : _raise_ms_exception();
47955 0 : msResetErrorList();
47956 0 : return NULL;
47957 : }
47958 : default:
47959 0 : _raise_ms_exception();
47960 0 : msResetErrorList();
47961 0 : return NULL;
47962 : }
47963 :
47964 : }
47965 : }
47966 : {
47967 1 : resultobj = PyBytes_FromStringAndSize((const char*)(&result)->data, (&result)->size);
47968 1 : if( (&result)->owns_data )
47969 1 : msFree((&result)->data);
47970 : }
47971 : return resultobj;
47972 1 : fail:
47973 : return NULL;
47974 : }
47975 :
47976 :
47977 1 : SWIGINTERN PyObject *_wrap_msIO_getAndStripStdoutBufferMimeHeaders(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47978 : PyObject *resultobj = 0;
47979 : hashTableObj *result = 0 ;
47980 :
47981 1 : if (!PyArg_ParseTuple(args,(char *)":msIO_getAndStripStdoutBufferMimeHeaders")) SWIG_fail;
47982 : {
47983 1 : result = (hashTableObj *)msIO_getAndStripStdoutBufferMimeHeaders(); {
47984 1 : errorObj *ms_error = msGetErrorObj();
47985 :
47986 1 : switch(ms_error->code) {
47987 : case MS_NOERR:
47988 : break;
47989 0 : case MS_NOTFOUND:
47990 0 : msResetErrorList();
47991 0 : break;
47992 : case -1:
47993 : break;
47994 0 : case MS_IOERR:
47995 0 : if (strcmp(ms_error->routine, "msSearchDiskTree()") != 0) {
47996 0 : _raise_ms_exception();
47997 0 : msResetErrorList();
47998 0 : return NULL;
47999 : }
48000 : default:
48001 0 : _raise_ms_exception();
48002 0 : msResetErrorList();
48003 0 : return NULL;
48004 : }
48005 :
48006 : }
48007 : }
48008 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_hashTableObj, SWIG_POINTER_OWN | 0 );
48009 1 : return resultobj;
48010 1 : fail:
48011 : return NULL;
48012 : }
48013 :
48014 :
48015 : static PyMethodDef SwigMethods[] = {
48016 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
48017 : { (char *)"new_intarray", _wrap_new_intarray, METH_VARARGS, NULL},
48018 : { (char *)"delete_intarray", _wrap_delete_intarray, METH_VARARGS, NULL},
48019 : { (char *)"intarray___getitem__", _wrap_intarray___getitem__, METH_VARARGS, NULL},
48020 : { (char *)"intarray___setitem__", _wrap_intarray___setitem__, METH_VARARGS, NULL},
48021 : { (char *)"intarray_cast", _wrap_intarray_cast, METH_VARARGS, NULL},
48022 : { (char *)"intarray_frompointer", _wrap_intarray_frompointer, METH_VARARGS, NULL},
48023 : { (char *)"intarray_swigregister", intarray_swigregister, METH_VARARGS, NULL},
48024 : { (char *)"CompositingFilter_filter_set", _wrap_CompositingFilter_filter_set, METH_VARARGS, NULL},
48025 : { (char *)"CompositingFilter_filter_get", _wrap_CompositingFilter_filter_get, METH_VARARGS, NULL},
48026 : { (char *)"CompositingFilter_next_set", _wrap_CompositingFilter_next_set, METH_VARARGS, NULL},
48027 : { (char *)"CompositingFilter_next_get", _wrap_CompositingFilter_next_get, METH_VARARGS, NULL},
48028 : { (char *)"new_CompositingFilter", _wrap_new_CompositingFilter, METH_VARARGS, NULL},
48029 : { (char *)"delete_CompositingFilter", _wrap_delete_CompositingFilter, METH_VARARGS, NULL},
48030 : { (char *)"CompositingFilter_swigregister", CompositingFilter_swigregister, METH_VARARGS, NULL},
48031 : { (char *)"LayerCompositer_comp_op_set", _wrap_LayerCompositer_comp_op_set, METH_VARARGS, NULL},
48032 : { (char *)"LayerCompositer_comp_op_get", _wrap_LayerCompositer_comp_op_get, METH_VARARGS, NULL},
48033 : { (char *)"LayerCompositer_opacity_set", _wrap_LayerCompositer_opacity_set, METH_VARARGS, NULL},
48034 : { (char *)"LayerCompositer_opacity_get", _wrap_LayerCompositer_opacity_get, METH_VARARGS, NULL},
48035 : { (char *)"LayerCompositer_filter_set", _wrap_LayerCompositer_filter_set, METH_VARARGS, NULL},
48036 : { (char *)"LayerCompositer_filter_get", _wrap_LayerCompositer_filter_get, METH_VARARGS, NULL},
48037 : { (char *)"LayerCompositer_next_set", _wrap_LayerCompositer_next_set, METH_VARARGS, NULL},
48038 : { (char *)"LayerCompositer_next_get", _wrap_LayerCompositer_next_get, METH_VARARGS, NULL},
48039 : { (char *)"new_LayerCompositer", _wrap_new_LayerCompositer, METH_VARARGS, NULL},
48040 : { (char *)"delete_LayerCompositer", _wrap_delete_LayerCompositer, METH_VARARGS, NULL},
48041 : { (char *)"LayerCompositer_swigregister", LayerCompositer_swigregister, METH_VARARGS, NULL},
48042 : { (char *)"fontSetObj_filename_get", _wrap_fontSetObj_filename_get, METH_VARARGS, NULL},
48043 : { (char *)"fontSetObj_numfonts_get", _wrap_fontSetObj_numfonts_get, METH_VARARGS, NULL},
48044 : { (char *)"fontSetObj_fonts_get", _wrap_fontSetObj_fonts_get, METH_VARARGS, NULL},
48045 : { (char *)"new_fontSetObj", _wrap_new_fontSetObj, METH_VARARGS, NULL},
48046 : { (char *)"delete_fontSetObj", _wrap_delete_fontSetObj, METH_VARARGS, NULL},
48047 : { (char *)"fontSetObj_swigregister", fontSetObj_swigregister, METH_VARARGS, NULL},
48048 : { (char *)"clusterObj_maxdistance_set", _wrap_clusterObj_maxdistance_set, METH_VARARGS, NULL},
48049 : { (char *)"clusterObj_maxdistance_get", _wrap_clusterObj_maxdistance_get, METH_VARARGS, NULL},
48050 : { (char *)"clusterObj_buffer_set", _wrap_clusterObj_buffer_set, METH_VARARGS, NULL},
48051 : { (char *)"clusterObj_buffer_get", _wrap_clusterObj_buffer_get, METH_VARARGS, NULL},
48052 : { (char *)"clusterObj_region_set", _wrap_clusterObj_region_set, METH_VARARGS, NULL},
48053 : { (char *)"clusterObj_region_get", _wrap_clusterObj_region_get, METH_VARARGS, NULL},
48054 : { (char *)"clusterObj_updateFromString", _wrap_clusterObj_updateFromString, METH_VARARGS, NULL},
48055 : { (char *)"clusterObj_convertToString", _wrap_clusterObj_convertToString, METH_VARARGS, NULL},
48056 : { (char *)"clusterObj_setGroup", _wrap_clusterObj_setGroup, METH_VARARGS, NULL},
48057 : { (char *)"clusterObj_getGroupString", _wrap_clusterObj_getGroupString, METH_VARARGS, NULL},
48058 : { (char *)"clusterObj_setFilter", _wrap_clusterObj_setFilter, METH_VARARGS, NULL},
48059 : { (char *)"clusterObj_getFilterString", _wrap_clusterObj_getFilterString, METH_VARARGS, NULL},
48060 : { (char *)"new_clusterObj", _wrap_new_clusterObj, METH_VARARGS, NULL},
48061 : { (char *)"delete_clusterObj", _wrap_delete_clusterObj, METH_VARARGS, NULL},
48062 : { (char *)"clusterObj_swigregister", clusterObj_swigregister, METH_VARARGS, NULL},
48063 : { (char *)"outputFormatObj_numformatoptions_get", _wrap_outputFormatObj_numformatoptions_get, METH_VARARGS, NULL},
48064 : { (char *)"outputFormatObj_name_set", _wrap_outputFormatObj_name_set, METH_VARARGS, NULL},
48065 : { (char *)"outputFormatObj_name_get", _wrap_outputFormatObj_name_get, METH_VARARGS, NULL},
48066 : { (char *)"outputFormatObj_mimetype_set", _wrap_outputFormatObj_mimetype_set, METH_VARARGS, NULL},
48067 : { (char *)"outputFormatObj_mimetype_get", _wrap_outputFormatObj_mimetype_get, METH_VARARGS, NULL},
48068 : { (char *)"outputFormatObj_driver_set", _wrap_outputFormatObj_driver_set, METH_VARARGS, NULL},
48069 : { (char *)"outputFormatObj_driver_get", _wrap_outputFormatObj_driver_get, METH_VARARGS, NULL},
48070 : { (char *)"outputFormatObj_extension_set", _wrap_outputFormatObj_extension_set, METH_VARARGS, NULL},
48071 : { (char *)"outputFormatObj_extension_get", _wrap_outputFormatObj_extension_get, METH_VARARGS, NULL},
48072 : { (char *)"outputFormatObj_renderer_set", _wrap_outputFormatObj_renderer_set, METH_VARARGS, NULL},
48073 : { (char *)"outputFormatObj_renderer_get", _wrap_outputFormatObj_renderer_get, METH_VARARGS, NULL},
48074 : { (char *)"outputFormatObj_imagemode_set", _wrap_outputFormatObj_imagemode_set, METH_VARARGS, NULL},
48075 : { (char *)"outputFormatObj_imagemode_get", _wrap_outputFormatObj_imagemode_get, METH_VARARGS, NULL},
48076 : { (char *)"outputFormatObj_transparent_set", _wrap_outputFormatObj_transparent_set, METH_VARARGS, NULL},
48077 : { (char *)"outputFormatObj_transparent_get", _wrap_outputFormatObj_transparent_get, METH_VARARGS, NULL},
48078 : { (char *)"outputFormatObj_bands_set", _wrap_outputFormatObj_bands_set, METH_VARARGS, NULL},
48079 : { (char *)"outputFormatObj_bands_get", _wrap_outputFormatObj_bands_get, METH_VARARGS, NULL},
48080 : { (char *)"outputFormatObj_inmapfile_set", _wrap_outputFormatObj_inmapfile_set, METH_VARARGS, NULL},
48081 : { (char *)"outputFormatObj_inmapfile_get", _wrap_outputFormatObj_inmapfile_get, METH_VARARGS, NULL},
48082 : { (char *)"new_outputFormatObj", _wrap_new_outputFormatObj, METH_VARARGS, NULL},
48083 : { (char *)"delete_outputFormatObj", _wrap_delete_outputFormatObj, METH_VARARGS, NULL},
48084 : { (char *)"outputFormatObj_setExtension", _wrap_outputFormatObj_setExtension, METH_VARARGS, NULL},
48085 : { (char *)"outputFormatObj_setMimetype", _wrap_outputFormatObj_setMimetype, METH_VARARGS, NULL},
48086 : { (char *)"outputFormatObj_setOption", _wrap_outputFormatObj_setOption, METH_VARARGS, NULL},
48087 : { (char *)"outputFormatObj_validate", _wrap_outputFormatObj_validate, METH_VARARGS, NULL},
48088 : { (char *)"outputFormatObj_getOption", _wrap_outputFormatObj_getOption, METH_VARARGS, NULL},
48089 : { (char *)"outputFormatObj_getOptionAt", _wrap_outputFormatObj_getOptionAt, METH_VARARGS, NULL},
48090 : { (char *)"outputFormatObj_attachDevice", _wrap_outputFormatObj_attachDevice, METH_VARARGS, NULL},
48091 : { (char *)"outputFormatObj_swigregister", outputFormatObj_swigregister, METH_VARARGS, NULL},
48092 : { (char *)"queryMapObj_height_set", _wrap_queryMapObj_height_set, METH_VARARGS, NULL},
48093 : { (char *)"queryMapObj_height_get", _wrap_queryMapObj_height_get, METH_VARARGS, NULL},
48094 : { (char *)"queryMapObj_width_set", _wrap_queryMapObj_width_set, METH_VARARGS, NULL},
48095 : { (char *)"queryMapObj_width_get", _wrap_queryMapObj_width_get, METH_VARARGS, NULL},
48096 : { (char *)"queryMapObj_status_set", _wrap_queryMapObj_status_set, METH_VARARGS, NULL},
48097 : { (char *)"queryMapObj_status_get", _wrap_queryMapObj_status_get, METH_VARARGS, NULL},
48098 : { (char *)"queryMapObj_style_set", _wrap_queryMapObj_style_set, METH_VARARGS, NULL},
48099 : { (char *)"queryMapObj_style_get", _wrap_queryMapObj_style_get, METH_VARARGS, NULL},
48100 : { (char *)"queryMapObj_color_set", _wrap_queryMapObj_color_set, METH_VARARGS, NULL},
48101 : { (char *)"queryMapObj_color_get", _wrap_queryMapObj_color_get, METH_VARARGS, NULL},
48102 : { (char *)"queryMapObj_updateFromString", _wrap_queryMapObj_updateFromString, METH_VARARGS, NULL},
48103 : { (char *)"queryMapObj_convertToString", _wrap_queryMapObj_convertToString, METH_VARARGS, NULL},
48104 : { (char *)"new_queryMapObj", _wrap_new_queryMapObj, METH_VARARGS, NULL},
48105 : { (char *)"delete_queryMapObj", _wrap_delete_queryMapObj, METH_VARARGS, NULL},
48106 : { (char *)"queryMapObj_swigregister", queryMapObj_swigregister, METH_VARARGS, NULL},
48107 : { (char *)"webObj_log_set", _wrap_webObj_log_set, METH_VARARGS, NULL},
48108 : { (char *)"webObj_log_get", _wrap_webObj_log_get, METH_VARARGS, NULL},
48109 : { (char *)"webObj_imagepath_set", _wrap_webObj_imagepath_set, METH_VARARGS, NULL},
48110 : { (char *)"webObj_imagepath_get", _wrap_webObj_imagepath_get, METH_VARARGS, NULL},
48111 : { (char *)"webObj_imageurl_set", _wrap_webObj_imageurl_set, METH_VARARGS, NULL},
48112 : { (char *)"webObj_imageurl_get", _wrap_webObj_imageurl_get, METH_VARARGS, NULL},
48113 : { (char *)"webObj_temppath_set", _wrap_webObj_temppath_set, METH_VARARGS, NULL},
48114 : { (char *)"webObj_temppath_get", _wrap_webObj_temppath_get, METH_VARARGS, NULL},
48115 : { (char *)"webObj_map_get", _wrap_webObj_map_get, METH_VARARGS, NULL},
48116 : { (char *)"webObj_template_set", _wrap_webObj_template_set, METH_VARARGS, NULL},
48117 : { (char *)"webObj_template_get", _wrap_webObj_template_get, METH_VARARGS, NULL},
48118 : { (char *)"webObj_header_set", _wrap_webObj_header_set, METH_VARARGS, NULL},
48119 : { (char *)"webObj_header_get", _wrap_webObj_header_get, METH_VARARGS, NULL},
48120 : { (char *)"webObj_footer_set", _wrap_webObj_footer_set, METH_VARARGS, NULL},
48121 : { (char *)"webObj_footer_get", _wrap_webObj_footer_get, METH_VARARGS, NULL},
48122 : { (char *)"webObj_empty_set", _wrap_webObj_empty_set, METH_VARARGS, NULL},
48123 : { (char *)"webObj_empty_get", _wrap_webObj_empty_get, METH_VARARGS, NULL},
48124 : { (char *)"webObj_error_set", _wrap_webObj_error_set, METH_VARARGS, NULL},
48125 : { (char *)"webObj_error_get", _wrap_webObj_error_get, METH_VARARGS, NULL},
48126 : { (char *)"webObj_extent_set", _wrap_webObj_extent_set, METH_VARARGS, NULL},
48127 : { (char *)"webObj_extent_get", _wrap_webObj_extent_get, METH_VARARGS, NULL},
48128 : { (char *)"webObj_minscaledenom_set", _wrap_webObj_minscaledenom_set, METH_VARARGS, NULL},
48129 : { (char *)"webObj_minscaledenom_get", _wrap_webObj_minscaledenom_get, METH_VARARGS, NULL},
48130 : { (char *)"webObj_maxscaledenom_set", _wrap_webObj_maxscaledenom_set, METH_VARARGS, NULL},
48131 : { (char *)"webObj_maxscaledenom_get", _wrap_webObj_maxscaledenom_get, METH_VARARGS, NULL},
48132 : { (char *)"webObj_mintemplate_set", _wrap_webObj_mintemplate_set, METH_VARARGS, NULL},
48133 : { (char *)"webObj_mintemplate_get", _wrap_webObj_mintemplate_get, METH_VARARGS, NULL},
48134 : { (char *)"webObj_maxtemplate_set", _wrap_webObj_maxtemplate_set, METH_VARARGS, NULL},
48135 : { (char *)"webObj_maxtemplate_get", _wrap_webObj_maxtemplate_get, METH_VARARGS, NULL},
48136 : { (char *)"webObj_queryformat_set", _wrap_webObj_queryformat_set, METH_VARARGS, NULL},
48137 : { (char *)"webObj_queryformat_get", _wrap_webObj_queryformat_get, METH_VARARGS, NULL},
48138 : { (char *)"webObj_legendformat_set", _wrap_webObj_legendformat_set, METH_VARARGS, NULL},
48139 : { (char *)"webObj_legendformat_get", _wrap_webObj_legendformat_get, METH_VARARGS, NULL},
48140 : { (char *)"webObj_browseformat_set", _wrap_webObj_browseformat_set, METH_VARARGS, NULL},
48141 : { (char *)"webObj_browseformat_get", _wrap_webObj_browseformat_get, METH_VARARGS, NULL},
48142 : { (char *)"webObj_metadata_get", _wrap_webObj_metadata_get, METH_VARARGS, NULL},
48143 : { (char *)"webObj_validation_get", _wrap_webObj_validation_get, METH_VARARGS, NULL},
48144 : { (char *)"new_webObj", _wrap_new_webObj, METH_VARARGS, NULL},
48145 : { (char *)"delete_webObj", _wrap_delete_webObj, METH_VARARGS, NULL},
48146 : { (char *)"webObj_updateFromString", _wrap_webObj_updateFromString, METH_VARARGS, NULL},
48147 : { (char *)"webObj_convertToString", _wrap_webObj_convertToString, METH_VARARGS, NULL},
48148 : { (char *)"webObj_swigregister", webObj_swigregister, METH_VARARGS, NULL},
48149 : { (char *)"styleObj_refcount_get", _wrap_styleObj_refcount_get, METH_VARARGS, NULL},
48150 : { (char *)"styleObj_symbolname_get", _wrap_styleObj_symbolname_get, METH_VARARGS, NULL},
48151 : { (char *)"styleObj_autoangle_set", _wrap_styleObj_autoangle_set, METH_VARARGS, NULL},
48152 : { (char *)"styleObj_autoangle_get", _wrap_styleObj_autoangle_get, METH_VARARGS, NULL},
48153 : { (char *)"styleObj_color_set", _wrap_styleObj_color_set, METH_VARARGS, NULL},
48154 : { (char *)"styleObj_color_get", _wrap_styleObj_color_get, METH_VARARGS, NULL},
48155 : { (char *)"styleObj_backgroundcolor_set", _wrap_styleObj_backgroundcolor_set, METH_VARARGS, NULL},
48156 : { (char *)"styleObj_backgroundcolor_get", _wrap_styleObj_backgroundcolor_get, METH_VARARGS, NULL},
48157 : { (char *)"styleObj_outlinecolor_set", _wrap_styleObj_outlinecolor_set, METH_VARARGS, NULL},
48158 : { (char *)"styleObj_outlinecolor_get", _wrap_styleObj_outlinecolor_get, METH_VARARGS, NULL},
48159 : { (char *)"styleObj_opacity_set", _wrap_styleObj_opacity_set, METH_VARARGS, NULL},
48160 : { (char *)"styleObj_opacity_get", _wrap_styleObj_opacity_get, METH_VARARGS, NULL},
48161 : { (char *)"styleObj_mincolor_set", _wrap_styleObj_mincolor_set, METH_VARARGS, NULL},
48162 : { (char *)"styleObj_mincolor_get", _wrap_styleObj_mincolor_get, METH_VARARGS, NULL},
48163 : { (char *)"styleObj_maxcolor_set", _wrap_styleObj_maxcolor_set, METH_VARARGS, NULL},
48164 : { (char *)"styleObj_maxcolor_get", _wrap_styleObj_maxcolor_get, METH_VARARGS, NULL},
48165 : { (char *)"styleObj_minvalue_set", _wrap_styleObj_minvalue_set, METH_VARARGS, NULL},
48166 : { (char *)"styleObj_minvalue_get", _wrap_styleObj_minvalue_get, METH_VARARGS, NULL},
48167 : { (char *)"styleObj_maxvalue_set", _wrap_styleObj_maxvalue_set, METH_VARARGS, NULL},
48168 : { (char *)"styleObj_maxvalue_get", _wrap_styleObj_maxvalue_get, METH_VARARGS, NULL},
48169 : { (char *)"styleObj_rangeitem_set", _wrap_styleObj_rangeitem_set, METH_VARARGS, NULL},
48170 : { (char *)"styleObj_rangeitem_get", _wrap_styleObj_rangeitem_get, METH_VARARGS, NULL},
48171 : { (char *)"styleObj_rangeitemindex_set", _wrap_styleObj_rangeitemindex_set, METH_VARARGS, NULL},
48172 : { (char *)"styleObj_rangeitemindex_get", _wrap_styleObj_rangeitemindex_get, METH_VARARGS, NULL},
48173 : { (char *)"styleObj_symbol_set", _wrap_styleObj_symbol_set, METH_VARARGS, NULL},
48174 : { (char *)"styleObj_symbol_get", _wrap_styleObj_symbol_get, METH_VARARGS, NULL},
48175 : { (char *)"styleObj_size_set", _wrap_styleObj_size_set, METH_VARARGS, NULL},
48176 : { (char *)"styleObj_size_get", _wrap_styleObj_size_get, METH_VARARGS, NULL},
48177 : { (char *)"styleObj_minsize_set", _wrap_styleObj_minsize_set, METH_VARARGS, NULL},
48178 : { (char *)"styleObj_minsize_get", _wrap_styleObj_minsize_get, METH_VARARGS, NULL},
48179 : { (char *)"styleObj_maxsize_set", _wrap_styleObj_maxsize_set, METH_VARARGS, NULL},
48180 : { (char *)"styleObj_maxsize_get", _wrap_styleObj_maxsize_get, METH_VARARGS, NULL},
48181 : { (char *)"styleObj_patternlength_get", _wrap_styleObj_patternlength_get, METH_VARARGS, NULL},
48182 : { (char *)"styleObj_gap_set", _wrap_styleObj_gap_set, METH_VARARGS, NULL},
48183 : { (char *)"styleObj_gap_get", _wrap_styleObj_gap_get, METH_VARARGS, NULL},
48184 : { (char *)"styleObj_initialgap_set", _wrap_styleObj_initialgap_set, METH_VARARGS, NULL},
48185 : { (char *)"styleObj_initialgap_get", _wrap_styleObj_initialgap_get, METH_VARARGS, NULL},
48186 : { (char *)"styleObj_position_set", _wrap_styleObj_position_set, METH_VARARGS, NULL},
48187 : { (char *)"styleObj_position_get", _wrap_styleObj_position_get, METH_VARARGS, NULL},
48188 : { (char *)"styleObj_linecap_set", _wrap_styleObj_linecap_set, METH_VARARGS, NULL},
48189 : { (char *)"styleObj_linecap_get", _wrap_styleObj_linecap_get, METH_VARARGS, NULL},
48190 : { (char *)"styleObj_linejoin_set", _wrap_styleObj_linejoin_set, METH_VARARGS, NULL},
48191 : { (char *)"styleObj_linejoin_get", _wrap_styleObj_linejoin_get, METH_VARARGS, NULL},
48192 : { (char *)"styleObj_linejoinmaxsize_set", _wrap_styleObj_linejoinmaxsize_set, METH_VARARGS, NULL},
48193 : { (char *)"styleObj_linejoinmaxsize_get", _wrap_styleObj_linejoinmaxsize_get, METH_VARARGS, NULL},
48194 : { (char *)"styleObj_width_set", _wrap_styleObj_width_set, METH_VARARGS, NULL},
48195 : { (char *)"styleObj_width_get", _wrap_styleObj_width_get, METH_VARARGS, NULL},
48196 : { (char *)"styleObj_outlinewidth_set", _wrap_styleObj_outlinewidth_set, METH_VARARGS, NULL},
48197 : { (char *)"styleObj_outlinewidth_get", _wrap_styleObj_outlinewidth_get, METH_VARARGS, NULL},
48198 : { (char *)"styleObj_minwidth_set", _wrap_styleObj_minwidth_set, METH_VARARGS, NULL},
48199 : { (char *)"styleObj_minwidth_get", _wrap_styleObj_minwidth_get, METH_VARARGS, NULL},
48200 : { (char *)"styleObj_maxwidth_set", _wrap_styleObj_maxwidth_set, METH_VARARGS, NULL},
48201 : { (char *)"styleObj_maxwidth_get", _wrap_styleObj_maxwidth_get, METH_VARARGS, NULL},
48202 : { (char *)"styleObj_offsetx_set", _wrap_styleObj_offsetx_set, METH_VARARGS, NULL},
48203 : { (char *)"styleObj_offsetx_get", _wrap_styleObj_offsetx_get, METH_VARARGS, NULL},
48204 : { (char *)"styleObj_offsety_set", _wrap_styleObj_offsety_set, METH_VARARGS, NULL},
48205 : { (char *)"styleObj_offsety_get", _wrap_styleObj_offsety_get, METH_VARARGS, NULL},
48206 : { (char *)"styleObj_polaroffsetpixel_set", _wrap_styleObj_polaroffsetpixel_set, METH_VARARGS, NULL},
48207 : { (char *)"styleObj_polaroffsetpixel_get", _wrap_styleObj_polaroffsetpixel_get, METH_VARARGS, NULL},
48208 : { (char *)"styleObj_polaroffsetangle_set", _wrap_styleObj_polaroffsetangle_set, METH_VARARGS, NULL},
48209 : { (char *)"styleObj_polaroffsetangle_get", _wrap_styleObj_polaroffsetangle_get, METH_VARARGS, NULL},
48210 : { (char *)"styleObj_angle_set", _wrap_styleObj_angle_set, METH_VARARGS, NULL},
48211 : { (char *)"styleObj_angle_get", _wrap_styleObj_angle_get, METH_VARARGS, NULL},
48212 : { (char *)"styleObj_minscaledenom_set", _wrap_styleObj_minscaledenom_set, METH_VARARGS, NULL},
48213 : { (char *)"styleObj_minscaledenom_get", _wrap_styleObj_minscaledenom_get, METH_VARARGS, NULL},
48214 : { (char *)"styleObj_maxscaledenom_set", _wrap_styleObj_maxscaledenom_set, METH_VARARGS, NULL},
48215 : { (char *)"styleObj_maxscaledenom_get", _wrap_styleObj_maxscaledenom_get, METH_VARARGS, NULL},
48216 : { (char *)"styleObj_sizeunits_set", _wrap_styleObj_sizeunits_set, METH_VARARGS, NULL},
48217 : { (char *)"styleObj_sizeunits_get", _wrap_styleObj_sizeunits_get, METH_VARARGS, NULL},
48218 : { (char *)"new_styleObj", _wrap_new_styleObj, METH_VARARGS, NULL},
48219 : { (char *)"delete_styleObj", _wrap_delete_styleObj, METH_VARARGS, NULL},
48220 : { (char *)"styleObj_updateFromString", _wrap_styleObj_updateFromString, METH_VARARGS, NULL},
48221 : { (char *)"styleObj_convertToString", _wrap_styleObj_convertToString, METH_VARARGS, NULL},
48222 : { (char *)"styleObj_clone", _wrap_styleObj_clone, METH_VARARGS, NULL},
48223 : { (char *)"styleObj_setSymbolByName", _wrap_styleObj_setSymbolByName, METH_VARARGS, NULL},
48224 : { (char *)"styleObj_removeBinding", _wrap_styleObj_removeBinding, METH_VARARGS, NULL},
48225 : { (char *)"styleObj_setBinding", _wrap_styleObj_setBinding, METH_VARARGS, NULL},
48226 : { (char *)"styleObj_getBinding", _wrap_styleObj_getBinding, METH_VARARGS, NULL},
48227 : { (char *)"styleObj_getGeomTransform", _wrap_styleObj_getGeomTransform, METH_VARARGS, NULL},
48228 : { (char *)"styleObj_setGeomTransform", _wrap_styleObj_setGeomTransform, METH_VARARGS, NULL},
48229 : { (char *)"styleObj_pattern_set", _wrap_styleObj_pattern_set, METH_VARARGS, NULL},
48230 : { (char *)"styleObj_pattern_get", _wrap_styleObj_pattern_get, METH_VARARGS, NULL},
48231 : { (char *)"styleObj_swigregister", styleObj_swigregister, METH_VARARGS, NULL},
48232 : { (char *)"labelLeaderObj_maxdistance_set", _wrap_labelLeaderObj_maxdistance_set, METH_VARARGS, NULL},
48233 : { (char *)"labelLeaderObj_maxdistance_get", _wrap_labelLeaderObj_maxdistance_get, METH_VARARGS, NULL},
48234 : { (char *)"labelLeaderObj_gridstep_set", _wrap_labelLeaderObj_gridstep_set, METH_VARARGS, NULL},
48235 : { (char *)"labelLeaderObj_gridstep_get", _wrap_labelLeaderObj_gridstep_get, METH_VARARGS, NULL},
48236 : { (char *)"labelLeaderObj_numstyles_get", _wrap_labelLeaderObj_numstyles_get, METH_VARARGS, NULL},
48237 : { (char *)"new_labelLeaderObj", _wrap_new_labelLeaderObj, METH_VARARGS, NULL},
48238 : { (char *)"delete_labelLeaderObj", _wrap_delete_labelLeaderObj, METH_VARARGS, NULL},
48239 : { (char *)"labelLeaderObj_swigregister", labelLeaderObj_swigregister, METH_VARARGS, NULL},
48240 : { (char *)"labelObj_refcount_get", _wrap_labelObj_refcount_get, METH_VARARGS, NULL},
48241 : { (char *)"labelObj_font_set", _wrap_labelObj_font_set, METH_VARARGS, NULL},
48242 : { (char *)"labelObj_font_get", _wrap_labelObj_font_get, METH_VARARGS, NULL},
48243 : { (char *)"labelObj_color_set", _wrap_labelObj_color_set, METH_VARARGS, NULL},
48244 : { (char *)"labelObj_color_get", _wrap_labelObj_color_get, METH_VARARGS, NULL},
48245 : { (char *)"labelObj_outlinecolor_set", _wrap_labelObj_outlinecolor_set, METH_VARARGS, NULL},
48246 : { (char *)"labelObj_outlinecolor_get", _wrap_labelObj_outlinecolor_get, METH_VARARGS, NULL},
48247 : { (char *)"labelObj_outlinewidth_set", _wrap_labelObj_outlinewidth_set, METH_VARARGS, NULL},
48248 : { (char *)"labelObj_outlinewidth_get", _wrap_labelObj_outlinewidth_get, METH_VARARGS, NULL},
48249 : { (char *)"labelObj_shadowcolor_set", _wrap_labelObj_shadowcolor_set, METH_VARARGS, NULL},
48250 : { (char *)"labelObj_shadowcolor_get", _wrap_labelObj_shadowcolor_get, METH_VARARGS, NULL},
48251 : { (char *)"labelObj_shadowsizex_set", _wrap_labelObj_shadowsizex_set, METH_VARARGS, NULL},
48252 : { (char *)"labelObj_shadowsizex_get", _wrap_labelObj_shadowsizex_get, METH_VARARGS, NULL},
48253 : { (char *)"labelObj_shadowsizey_set", _wrap_labelObj_shadowsizey_set, METH_VARARGS, NULL},
48254 : { (char *)"labelObj_shadowsizey_get", _wrap_labelObj_shadowsizey_get, METH_VARARGS, NULL},
48255 : { (char *)"labelObj_size_set", _wrap_labelObj_size_set, METH_VARARGS, NULL},
48256 : { (char *)"labelObj_size_get", _wrap_labelObj_size_get, METH_VARARGS, NULL},
48257 : { (char *)"labelObj_minsize_set", _wrap_labelObj_minsize_set, METH_VARARGS, NULL},
48258 : { (char *)"labelObj_minsize_get", _wrap_labelObj_minsize_get, METH_VARARGS, NULL},
48259 : { (char *)"labelObj_maxsize_set", _wrap_labelObj_maxsize_set, METH_VARARGS, NULL},
48260 : { (char *)"labelObj_maxsize_get", _wrap_labelObj_maxsize_get, METH_VARARGS, NULL},
48261 : { (char *)"labelObj_position_set", _wrap_labelObj_position_set, METH_VARARGS, NULL},
48262 : { (char *)"labelObj_position_get", _wrap_labelObj_position_get, METH_VARARGS, NULL},
48263 : { (char *)"labelObj_offsetx_set", _wrap_labelObj_offsetx_set, METH_VARARGS, NULL},
48264 : { (char *)"labelObj_offsetx_get", _wrap_labelObj_offsetx_get, METH_VARARGS, NULL},
48265 : { (char *)"labelObj_offsety_set", _wrap_labelObj_offsety_set, METH_VARARGS, NULL},
48266 : { (char *)"labelObj_offsety_get", _wrap_labelObj_offsety_get, METH_VARARGS, NULL},
48267 : { (char *)"labelObj_angle_set", _wrap_labelObj_angle_set, METH_VARARGS, NULL},
48268 : { (char *)"labelObj_angle_get", _wrap_labelObj_angle_get, METH_VARARGS, NULL},
48269 : { (char *)"labelObj_anglemode_set", _wrap_labelObj_anglemode_set, METH_VARARGS, NULL},
48270 : { (char *)"labelObj_anglemode_get", _wrap_labelObj_anglemode_get, METH_VARARGS, NULL},
48271 : { (char *)"labelObj_buffer_set", _wrap_labelObj_buffer_set, METH_VARARGS, NULL},
48272 : { (char *)"labelObj_buffer_get", _wrap_labelObj_buffer_get, METH_VARARGS, NULL},
48273 : { (char *)"labelObj_align_set", _wrap_labelObj_align_set, METH_VARARGS, NULL},
48274 : { (char *)"labelObj_align_get", _wrap_labelObj_align_get, METH_VARARGS, NULL},
48275 : { (char *)"labelObj_wrap_set", _wrap_labelObj_wrap_set, METH_VARARGS, NULL},
48276 : { (char *)"labelObj_wrap_get", _wrap_labelObj_wrap_get, METH_VARARGS, NULL},
48277 : { (char *)"labelObj_maxlength_set", _wrap_labelObj_maxlength_set, METH_VARARGS, NULL},
48278 : { (char *)"labelObj_maxlength_get", _wrap_labelObj_maxlength_get, METH_VARARGS, NULL},
48279 : { (char *)"labelObj_minlength_set", _wrap_labelObj_minlength_set, METH_VARARGS, NULL},
48280 : { (char *)"labelObj_minlength_get", _wrap_labelObj_minlength_get, METH_VARARGS, NULL},
48281 : { (char *)"labelObj_space_size_10_set", _wrap_labelObj_space_size_10_set, METH_VARARGS, NULL},
48282 : { (char *)"labelObj_space_size_10_get", _wrap_labelObj_space_size_10_get, METH_VARARGS, NULL},
48283 : { (char *)"labelObj_minfeaturesize_set", _wrap_labelObj_minfeaturesize_set, METH_VARARGS, NULL},
48284 : { (char *)"labelObj_minfeaturesize_get", _wrap_labelObj_minfeaturesize_get, METH_VARARGS, NULL},
48285 : { (char *)"labelObj_autominfeaturesize_set", _wrap_labelObj_autominfeaturesize_set, METH_VARARGS, NULL},
48286 : { (char *)"labelObj_autominfeaturesize_get", _wrap_labelObj_autominfeaturesize_get, METH_VARARGS, NULL},
48287 : { (char *)"labelObj_minscaledenom_set", _wrap_labelObj_minscaledenom_set, METH_VARARGS, NULL},
48288 : { (char *)"labelObj_minscaledenom_get", _wrap_labelObj_minscaledenom_get, METH_VARARGS, NULL},
48289 : { (char *)"labelObj_maxscaledenom_set", _wrap_labelObj_maxscaledenom_set, METH_VARARGS, NULL},
48290 : { (char *)"labelObj_maxscaledenom_get", _wrap_labelObj_maxscaledenom_get, METH_VARARGS, NULL},
48291 : { (char *)"labelObj_mindistance_set", _wrap_labelObj_mindistance_set, METH_VARARGS, NULL},
48292 : { (char *)"labelObj_mindistance_get", _wrap_labelObj_mindistance_get, METH_VARARGS, NULL},
48293 : { (char *)"labelObj_repeatdistance_set", _wrap_labelObj_repeatdistance_set, METH_VARARGS, NULL},
48294 : { (char *)"labelObj_repeatdistance_get", _wrap_labelObj_repeatdistance_get, METH_VARARGS, NULL},
48295 : { (char *)"labelObj_maxoverlapangle_set", _wrap_labelObj_maxoverlapangle_set, METH_VARARGS, NULL},
48296 : { (char *)"labelObj_maxoverlapangle_get", _wrap_labelObj_maxoverlapangle_get, METH_VARARGS, NULL},
48297 : { (char *)"labelObj_partials_set", _wrap_labelObj_partials_set, METH_VARARGS, NULL},
48298 : { (char *)"labelObj_partials_get", _wrap_labelObj_partials_get, METH_VARARGS, NULL},
48299 : { (char *)"labelObj_force_set", _wrap_labelObj_force_set, METH_VARARGS, NULL},
48300 : { (char *)"labelObj_force_get", _wrap_labelObj_force_get, METH_VARARGS, NULL},
48301 : { (char *)"labelObj_encoding_set", _wrap_labelObj_encoding_set, METH_VARARGS, NULL},
48302 : { (char *)"labelObj_encoding_get", _wrap_labelObj_encoding_get, METH_VARARGS, NULL},
48303 : { (char *)"labelObj_priority_set", _wrap_labelObj_priority_set, METH_VARARGS, NULL},
48304 : { (char *)"labelObj_priority_get", _wrap_labelObj_priority_get, METH_VARARGS, NULL},
48305 : { (char *)"labelObj_numstyles_set", _wrap_labelObj_numstyles_set, METH_VARARGS, NULL},
48306 : { (char *)"labelObj_numstyles_get", _wrap_labelObj_numstyles_get, METH_VARARGS, NULL},
48307 : { (char *)"labelObj_leader_set", _wrap_labelObj_leader_set, METH_VARARGS, NULL},
48308 : { (char *)"labelObj_leader_get", _wrap_labelObj_leader_get, METH_VARARGS, NULL},
48309 : { (char *)"labelObj_sizeunits_set", _wrap_labelObj_sizeunits_set, METH_VARARGS, NULL},
48310 : { (char *)"labelObj_sizeunits_get", _wrap_labelObj_sizeunits_get, METH_VARARGS, NULL},
48311 : { (char *)"new_labelObj", _wrap_new_labelObj, METH_VARARGS, NULL},
48312 : { (char *)"delete_labelObj", _wrap_delete_labelObj, METH_VARARGS, NULL},
48313 : { (char *)"labelObj_updateFromString", _wrap_labelObj_updateFromString, METH_VARARGS, NULL},
48314 : { (char *)"labelObj_convertToString", _wrap_labelObj_convertToString, METH_VARARGS, NULL},
48315 : { (char *)"labelObj_removeBinding", _wrap_labelObj_removeBinding, METH_VARARGS, NULL},
48316 : { (char *)"labelObj_getBinding", _wrap_labelObj_getBinding, METH_VARARGS, NULL},
48317 : { (char *)"labelObj_setBinding", _wrap_labelObj_setBinding, METH_VARARGS, NULL},
48318 : { (char *)"labelObj_setExpression", _wrap_labelObj_setExpression, METH_VARARGS, NULL},
48319 : { (char *)"labelObj_getExpressionString", _wrap_labelObj_getExpressionString, METH_VARARGS, NULL},
48320 : { (char *)"labelObj_setText", _wrap_labelObj_setText, METH_VARARGS, NULL},
48321 : { (char *)"labelObj_getTextString", _wrap_labelObj_getTextString, METH_VARARGS, NULL},
48322 : { (char *)"labelObj_getStyle", _wrap_labelObj_getStyle, METH_VARARGS, NULL},
48323 : { (char *)"labelObj_insertStyle", _wrap_labelObj_insertStyle, METH_VARARGS, NULL},
48324 : { (char *)"labelObj_removeStyle", _wrap_labelObj_removeStyle, METH_VARARGS, NULL},
48325 : { (char *)"labelObj_moveStyleUp", _wrap_labelObj_moveStyleUp, METH_VARARGS, NULL},
48326 : { (char *)"labelObj_moveStyleDown", _wrap_labelObj_moveStyleDown, METH_VARARGS, NULL},
48327 : { (char *)"labelObj_swigregister", labelObj_swigregister, METH_VARARGS, NULL},
48328 : { (char *)"classObj_metadata_get", _wrap_classObj_metadata_get, METH_VARARGS, NULL},
48329 : { (char *)"classObj_validation_get", _wrap_classObj_validation_get, METH_VARARGS, NULL},
48330 : { (char *)"classObj_numstyles_get", _wrap_classObj_numstyles_get, METH_VARARGS, NULL},
48331 : { (char *)"classObj_numlabels_get", _wrap_classObj_numlabels_get, METH_VARARGS, NULL},
48332 : { (char *)"classObj_refcount_get", _wrap_classObj_refcount_get, METH_VARARGS, NULL},
48333 : { (char *)"classObj_layer_get", _wrap_classObj_layer_get, METH_VARARGS, NULL},
48334 : { (char *)"classObj_leader_get", _wrap_classObj_leader_get, METH_VARARGS, NULL},
48335 : { (char *)"classObj_status_set", _wrap_classObj_status_set, METH_VARARGS, NULL},
48336 : { (char *)"classObj_status_get", _wrap_classObj_status_get, METH_VARARGS, NULL},
48337 : { (char *)"classObj_isfallback_set", _wrap_classObj_isfallback_set, METH_VARARGS, NULL},
48338 : { (char *)"classObj_isfallback_get", _wrap_classObj_isfallback_get, METH_VARARGS, NULL},
48339 : { (char *)"classObj_name_set", _wrap_classObj_name_set, METH_VARARGS, NULL},
48340 : { (char *)"classObj_name_get", _wrap_classObj_name_get, METH_VARARGS, NULL},
48341 : { (char *)"classObj_title_set", _wrap_classObj_title_set, METH_VARARGS, NULL},
48342 : { (char *)"classObj_title_get", _wrap_classObj_title_get, METH_VARARGS, NULL},
48343 : { (char *)"classObj_minscaledenom_set", _wrap_classObj_minscaledenom_set, METH_VARARGS, NULL},
48344 : { (char *)"classObj_minscaledenom_get", _wrap_classObj_minscaledenom_get, METH_VARARGS, NULL},
48345 : { (char *)"classObj_maxscaledenom_set", _wrap_classObj_maxscaledenom_set, METH_VARARGS, NULL},
48346 : { (char *)"classObj_maxscaledenom_get", _wrap_classObj_maxscaledenom_get, METH_VARARGS, NULL},
48347 : { (char *)"classObj_minfeaturesize_set", _wrap_classObj_minfeaturesize_set, METH_VARARGS, NULL},
48348 : { (char *)"classObj_minfeaturesize_get", _wrap_classObj_minfeaturesize_get, METH_VARARGS, NULL},
48349 : { (char *)"classObj_debug_set", _wrap_classObj_debug_set, METH_VARARGS, NULL},
48350 : { (char *)"classObj_debug_get", _wrap_classObj_debug_get, METH_VARARGS, NULL},
48351 : { (char *)"classObj_keyimage_set", _wrap_classObj_keyimage_set, METH_VARARGS, NULL},
48352 : { (char *)"classObj_keyimage_get", _wrap_classObj_keyimage_get, METH_VARARGS, NULL},
48353 : { (char *)"classObj_group_set", _wrap_classObj_group_set, METH_VARARGS, NULL},
48354 : { (char *)"classObj_group_get", _wrap_classObj_group_get, METH_VARARGS, NULL},
48355 : { (char *)"classObj_sizeunits_set", _wrap_classObj_sizeunits_set, METH_VARARGS, NULL},
48356 : { (char *)"classObj_sizeunits_get", _wrap_classObj_sizeunits_get, METH_VARARGS, NULL},
48357 : { (char *)"classObj_template_set", _wrap_classObj_template_set, METH_VARARGS, NULL},
48358 : { (char *)"classObj_template_get", _wrap_classObj_template_get, METH_VARARGS, NULL},
48359 : { (char *)"new_classObj", _wrap_new_classObj, METH_VARARGS, NULL},
48360 : { (char *)"delete_classObj", _wrap_delete_classObj, METH_VARARGS, NULL},
48361 : { (char *)"classObj_updateFromString", _wrap_classObj_updateFromString, METH_VARARGS, NULL},
48362 : { (char *)"classObj_convertToString", _wrap_classObj_convertToString, METH_VARARGS, NULL},
48363 : { (char *)"classObj_clone", _wrap_classObj_clone, METH_VARARGS, NULL},
48364 : { (char *)"classObj_setExpression", _wrap_classObj_setExpression, METH_VARARGS, NULL},
48365 : { (char *)"classObj_getExpressionString", _wrap_classObj_getExpressionString, METH_VARARGS, NULL},
48366 : { (char *)"classObj_setText", _wrap_classObj_setText, METH_VARARGS, NULL},
48367 : { (char *)"classObj_getTextString", _wrap_classObj_getTextString, METH_VARARGS, NULL},
48368 : { (char *)"classObj_getMetaData", _wrap_classObj_getMetaData, METH_VARARGS, NULL},
48369 : { (char *)"classObj_setMetaData", _wrap_classObj_setMetaData, METH_VARARGS, NULL},
48370 : { (char *)"classObj_getFirstMetaDataKey", _wrap_classObj_getFirstMetaDataKey, METH_VARARGS, NULL},
48371 : { (char *)"classObj_getNextMetaDataKey", _wrap_classObj_getNextMetaDataKey, METH_VARARGS, NULL},
48372 : { (char *)"classObj_drawLegendIcon", _wrap_classObj_drawLegendIcon, METH_VARARGS, NULL},
48373 : { (char *)"classObj_createLegendIcon", _wrap_classObj_createLegendIcon, METH_VARARGS, NULL},
48374 : { (char *)"classObj_getLabel", _wrap_classObj_getLabel, METH_VARARGS, NULL},
48375 : { (char *)"classObj_addLabel", _wrap_classObj_addLabel, METH_VARARGS, NULL},
48376 : { (char *)"classObj_removeLabel", _wrap_classObj_removeLabel, METH_VARARGS, NULL},
48377 : { (char *)"classObj_getStyle", _wrap_classObj_getStyle, METH_VARARGS, NULL},
48378 : { (char *)"classObj_insertStyle", _wrap_classObj_insertStyle, METH_VARARGS, NULL},
48379 : { (char *)"classObj_removeStyle", _wrap_classObj_removeStyle, METH_VARARGS, NULL},
48380 : { (char *)"classObj_moveStyleUp", _wrap_classObj_moveStyleUp, METH_VARARGS, NULL},
48381 : { (char *)"classObj_moveStyleDown", _wrap_classObj_moveStyleDown, METH_VARARGS, NULL},
48382 : { (char *)"classObj_swigregister", classObj_swigregister, METH_VARARGS, NULL},
48383 : { (char *)"labelCacheMemberObj_textsymbols_get", _wrap_labelCacheMemberObj_textsymbols_get, METH_VARARGS, NULL},
48384 : { (char *)"labelCacheMemberObj_numtextsymbols_get", _wrap_labelCacheMemberObj_numtextsymbols_get, METH_VARARGS, NULL},
48385 : { (char *)"labelCacheMemberObj_layerindex_get", _wrap_labelCacheMemberObj_layerindex_get, METH_VARARGS, NULL},
48386 : { (char *)"labelCacheMemberObj_classindex_get", _wrap_labelCacheMemberObj_classindex_get, METH_VARARGS, NULL},
48387 : { (char *)"labelCacheMemberObj_point_get", _wrap_labelCacheMemberObj_point_get, METH_VARARGS, NULL},
48388 : { (char *)"labelCacheMemberObj_bbox_get", _wrap_labelCacheMemberObj_bbox_get, METH_VARARGS, NULL},
48389 : { (char *)"labelCacheMemberObj_status_get", _wrap_labelCacheMemberObj_status_get, METH_VARARGS, NULL},
48390 : { (char *)"labelCacheMemberObj_markerid_get", _wrap_labelCacheMemberObj_markerid_get, METH_VARARGS, NULL},
48391 : { (char *)"labelCacheMemberObj_leaderline_get", _wrap_labelCacheMemberObj_leaderline_get, METH_VARARGS, NULL},
48392 : { (char *)"labelCacheMemberObj_leaderbbox_get", _wrap_labelCacheMemberObj_leaderbbox_get, METH_VARARGS, NULL},
48393 : { (char *)"new_labelCacheMemberObj", _wrap_new_labelCacheMemberObj, METH_VARARGS, NULL},
48394 : { (char *)"delete_labelCacheMemberObj", _wrap_delete_labelCacheMemberObj, METH_VARARGS, NULL},
48395 : { (char *)"labelCacheMemberObj_swigregister", labelCacheMemberObj_swigregister, METH_VARARGS, NULL},
48396 : { (char *)"markerCacheMemberObj_id_get", _wrap_markerCacheMemberObj_id_get, METH_VARARGS, NULL},
48397 : { (char *)"markerCacheMemberObj_bounds_get", _wrap_markerCacheMemberObj_bounds_get, METH_VARARGS, NULL},
48398 : { (char *)"new_markerCacheMemberObj", _wrap_new_markerCacheMemberObj, METH_VARARGS, NULL},
48399 : { (char *)"delete_markerCacheMemberObj", _wrap_delete_markerCacheMemberObj, METH_VARARGS, NULL},
48400 : { (char *)"markerCacheMemberObj_swigregister", markerCacheMemberObj_swigregister, METH_VARARGS, NULL},
48401 : { (char *)"labelCacheSlotObj_labels_get", _wrap_labelCacheSlotObj_labels_get, METH_VARARGS, NULL},
48402 : { (char *)"labelCacheSlotObj_numlabels_get", _wrap_labelCacheSlotObj_numlabels_get, METH_VARARGS, NULL},
48403 : { (char *)"labelCacheSlotObj_cachesize_get", _wrap_labelCacheSlotObj_cachesize_get, METH_VARARGS, NULL},
48404 : { (char *)"labelCacheSlotObj_markers_get", _wrap_labelCacheSlotObj_markers_get, METH_VARARGS, NULL},
48405 : { (char *)"labelCacheSlotObj_nummarkers_get", _wrap_labelCacheSlotObj_nummarkers_get, METH_VARARGS, NULL},
48406 : { (char *)"labelCacheSlotObj_markercachesize_get", _wrap_labelCacheSlotObj_markercachesize_get, METH_VARARGS, NULL},
48407 : { (char *)"new_labelCacheSlotObj", _wrap_new_labelCacheSlotObj, METH_VARARGS, NULL},
48408 : { (char *)"delete_labelCacheSlotObj", _wrap_delete_labelCacheSlotObj, METH_VARARGS, NULL},
48409 : { (char *)"labelCacheSlotObj_swigregister", labelCacheSlotObj_swigregister, METH_VARARGS, NULL},
48410 : { (char *)"labelCacheObj_slots_get", _wrap_labelCacheObj_slots_get, METH_VARARGS, NULL},
48411 : { (char *)"labelCacheObj_gutter_get", _wrap_labelCacheObj_gutter_get, METH_VARARGS, NULL},
48412 : { (char *)"labelCacheObj_rendered_text_symbols_get", _wrap_labelCacheObj_rendered_text_symbols_get, METH_VARARGS, NULL},
48413 : { (char *)"labelCacheObj_num_allocated_rendered_members_get", _wrap_labelCacheObj_num_allocated_rendered_members_get, METH_VARARGS, NULL},
48414 : { (char *)"labelCacheObj_num_rendered_members_get", _wrap_labelCacheObj_num_rendered_members_get, METH_VARARGS, NULL},
48415 : { (char *)"labelCacheObj_freeCache", _wrap_labelCacheObj_freeCache, METH_VARARGS, NULL},
48416 : { (char *)"new_labelCacheObj", _wrap_new_labelCacheObj, METH_VARARGS, NULL},
48417 : { (char *)"delete_labelCacheObj", _wrap_delete_labelCacheObj, METH_VARARGS, NULL},
48418 : { (char *)"labelCacheObj_swigregister", labelCacheObj_swigregister, METH_VARARGS, NULL},
48419 : { (char *)"resultObj_shapeindex_get", _wrap_resultObj_shapeindex_get, METH_VARARGS, NULL},
48420 : { (char *)"resultObj_tileindex_get", _wrap_resultObj_tileindex_get, METH_VARARGS, NULL},
48421 : { (char *)"resultObj_resultindex_get", _wrap_resultObj_resultindex_get, METH_VARARGS, NULL},
48422 : { (char *)"resultObj_classindex_get", _wrap_resultObj_classindex_get, METH_VARARGS, NULL},
48423 : { (char *)"new_resultObj", _wrap_new_resultObj, METH_VARARGS, NULL},
48424 : { (char *)"delete_resultObj", _wrap_delete_resultObj, METH_VARARGS, NULL},
48425 : { (char *)"resultObj_swigregister", resultObj_swigregister, METH_VARARGS, NULL},
48426 : { (char *)"resultCacheObj_numresults_get", _wrap_resultCacheObj_numresults_get, METH_VARARGS, NULL},
48427 : { (char *)"resultCacheObj_bounds_get", _wrap_resultCacheObj_bounds_get, METH_VARARGS, NULL},
48428 : { (char *)"resultCacheObj_usegetshape_set", _wrap_resultCacheObj_usegetshape_set, METH_VARARGS, NULL},
48429 : { (char *)"resultCacheObj_usegetshape_get", _wrap_resultCacheObj_usegetshape_get, METH_VARARGS, NULL},
48430 : { (char *)"resultCacheObj_getResult", _wrap_resultCacheObj_getResult, METH_VARARGS, NULL},
48431 : { (char *)"new_resultCacheObj", _wrap_new_resultCacheObj, METH_VARARGS, NULL},
48432 : { (char *)"delete_resultCacheObj", _wrap_delete_resultCacheObj, METH_VARARGS, NULL},
48433 : { (char *)"resultCacheObj_swigregister", resultCacheObj_swigregister, METH_VARARGS, NULL},
48434 : { (char *)"symbolSetObj_filename_set", _wrap_symbolSetObj_filename_set, METH_VARARGS, NULL},
48435 : { (char *)"symbolSetObj_filename_get", _wrap_symbolSetObj_filename_get, METH_VARARGS, NULL},
48436 : { (char *)"symbolSetObj_imagecachesize_set", _wrap_symbolSetObj_imagecachesize_set, METH_VARARGS, NULL},
48437 : { (char *)"symbolSetObj_imagecachesize_get", _wrap_symbolSetObj_imagecachesize_get, METH_VARARGS, NULL},
48438 : { (char *)"symbolSetObj_numsymbols_get", _wrap_symbolSetObj_numsymbols_get, METH_VARARGS, NULL},
48439 : { (char *)"symbolSetObj_maxsymbols_get", _wrap_symbolSetObj_maxsymbols_get, METH_VARARGS, NULL},
48440 : { (char *)"new_symbolSetObj", _wrap_new_symbolSetObj, METH_VARARGS, NULL},
48441 : { (char *)"delete_symbolSetObj", _wrap_delete_symbolSetObj, METH_VARARGS, NULL},
48442 : { (char *)"symbolSetObj_getSymbol", _wrap_symbolSetObj_getSymbol, METH_VARARGS, NULL},
48443 : { (char *)"symbolSetObj_getSymbolByName", _wrap_symbolSetObj_getSymbolByName, METH_VARARGS, NULL},
48444 : { (char *)"symbolSetObj_index", _wrap_symbolSetObj_index, METH_VARARGS, NULL},
48445 : { (char *)"symbolSetObj_appendSymbol", _wrap_symbolSetObj_appendSymbol, METH_VARARGS, NULL},
48446 : { (char *)"symbolSetObj_removeSymbol", _wrap_symbolSetObj_removeSymbol, METH_VARARGS, NULL},
48447 : { (char *)"symbolSetObj_save", _wrap_symbolSetObj_save, METH_VARARGS, NULL},
48448 : { (char *)"symbolSetObj_swigregister", symbolSetObj_swigregister, METH_VARARGS, NULL},
48449 : { (char *)"referenceMapObj_extent_set", _wrap_referenceMapObj_extent_set, METH_VARARGS, NULL},
48450 : { (char *)"referenceMapObj_extent_get", _wrap_referenceMapObj_extent_get, METH_VARARGS, NULL},
48451 : { (char *)"referenceMapObj_height_set", _wrap_referenceMapObj_height_set, METH_VARARGS, NULL},
48452 : { (char *)"referenceMapObj_height_get", _wrap_referenceMapObj_height_get, METH_VARARGS, NULL},
48453 : { (char *)"referenceMapObj_width_set", _wrap_referenceMapObj_width_set, METH_VARARGS, NULL},
48454 : { (char *)"referenceMapObj_width_get", _wrap_referenceMapObj_width_get, METH_VARARGS, NULL},
48455 : { (char *)"referenceMapObj_color_set", _wrap_referenceMapObj_color_set, METH_VARARGS, NULL},
48456 : { (char *)"referenceMapObj_color_get", _wrap_referenceMapObj_color_get, METH_VARARGS, NULL},
48457 : { (char *)"referenceMapObj_outlinecolor_set", _wrap_referenceMapObj_outlinecolor_set, METH_VARARGS, NULL},
48458 : { (char *)"referenceMapObj_outlinecolor_get", _wrap_referenceMapObj_outlinecolor_get, METH_VARARGS, NULL},
48459 : { (char *)"referenceMapObj_image_set", _wrap_referenceMapObj_image_set, METH_VARARGS, NULL},
48460 : { (char *)"referenceMapObj_image_get", _wrap_referenceMapObj_image_get, METH_VARARGS, NULL},
48461 : { (char *)"referenceMapObj_status_set", _wrap_referenceMapObj_status_set, METH_VARARGS, NULL},
48462 : { (char *)"referenceMapObj_status_get", _wrap_referenceMapObj_status_get, METH_VARARGS, NULL},
48463 : { (char *)"referenceMapObj_marker_set", _wrap_referenceMapObj_marker_set, METH_VARARGS, NULL},
48464 : { (char *)"referenceMapObj_marker_get", _wrap_referenceMapObj_marker_get, METH_VARARGS, NULL},
48465 : { (char *)"referenceMapObj_markername_set", _wrap_referenceMapObj_markername_set, METH_VARARGS, NULL},
48466 : { (char *)"referenceMapObj_markername_get", _wrap_referenceMapObj_markername_get, METH_VARARGS, NULL},
48467 : { (char *)"referenceMapObj_markersize_set", _wrap_referenceMapObj_markersize_set, METH_VARARGS, NULL},
48468 : { (char *)"referenceMapObj_markersize_get", _wrap_referenceMapObj_markersize_get, METH_VARARGS, NULL},
48469 : { (char *)"referenceMapObj_minboxsize_set", _wrap_referenceMapObj_minboxsize_set, METH_VARARGS, NULL},
48470 : { (char *)"referenceMapObj_minboxsize_get", _wrap_referenceMapObj_minboxsize_get, METH_VARARGS, NULL},
48471 : { (char *)"referenceMapObj_maxboxsize_set", _wrap_referenceMapObj_maxboxsize_set, METH_VARARGS, NULL},
48472 : { (char *)"referenceMapObj_maxboxsize_get", _wrap_referenceMapObj_maxboxsize_get, METH_VARARGS, NULL},
48473 : { (char *)"referenceMapObj_map_get", _wrap_referenceMapObj_map_get, METH_VARARGS, NULL},
48474 : { (char *)"referenceMapObj_updateFromString", _wrap_referenceMapObj_updateFromString, METH_VARARGS, NULL},
48475 : { (char *)"referenceMapObj_convertToString", _wrap_referenceMapObj_convertToString, METH_VARARGS, NULL},
48476 : { (char *)"new_referenceMapObj", _wrap_new_referenceMapObj, METH_VARARGS, NULL},
48477 : { (char *)"delete_referenceMapObj", _wrap_delete_referenceMapObj, METH_VARARGS, NULL},
48478 : { (char *)"referenceMapObj_swigregister", referenceMapObj_swigregister, METH_VARARGS, NULL},
48479 : { (char *)"scalebarObj_imagecolor_set", _wrap_scalebarObj_imagecolor_set, METH_VARARGS, NULL},
48480 : { (char *)"scalebarObj_imagecolor_get", _wrap_scalebarObj_imagecolor_get, METH_VARARGS, NULL},
48481 : { (char *)"scalebarObj_height_set", _wrap_scalebarObj_height_set, METH_VARARGS, NULL},
48482 : { (char *)"scalebarObj_height_get", _wrap_scalebarObj_height_get, METH_VARARGS, NULL},
48483 : { (char *)"scalebarObj_width_set", _wrap_scalebarObj_width_set, METH_VARARGS, NULL},
48484 : { (char *)"scalebarObj_width_get", _wrap_scalebarObj_width_get, METH_VARARGS, NULL},
48485 : { (char *)"scalebarObj_style_set", _wrap_scalebarObj_style_set, METH_VARARGS, NULL},
48486 : { (char *)"scalebarObj_style_get", _wrap_scalebarObj_style_get, METH_VARARGS, NULL},
48487 : { (char *)"scalebarObj_intervals_set", _wrap_scalebarObj_intervals_set, METH_VARARGS, NULL},
48488 : { (char *)"scalebarObj_intervals_get", _wrap_scalebarObj_intervals_get, METH_VARARGS, NULL},
48489 : { (char *)"scalebarObj_label_set", _wrap_scalebarObj_label_set, METH_VARARGS, NULL},
48490 : { (char *)"scalebarObj_label_get", _wrap_scalebarObj_label_get, METH_VARARGS, NULL},
48491 : { (char *)"scalebarObj_color_set", _wrap_scalebarObj_color_set, METH_VARARGS, NULL},
48492 : { (char *)"scalebarObj_color_get", _wrap_scalebarObj_color_get, METH_VARARGS, NULL},
48493 : { (char *)"scalebarObj_backgroundcolor_set", _wrap_scalebarObj_backgroundcolor_set, METH_VARARGS, NULL},
48494 : { (char *)"scalebarObj_backgroundcolor_get", _wrap_scalebarObj_backgroundcolor_get, METH_VARARGS, NULL},
48495 : { (char *)"scalebarObj_outlinecolor_set", _wrap_scalebarObj_outlinecolor_set, METH_VARARGS, NULL},
48496 : { (char *)"scalebarObj_outlinecolor_get", _wrap_scalebarObj_outlinecolor_get, METH_VARARGS, NULL},
48497 : { (char *)"scalebarObj_units_set", _wrap_scalebarObj_units_set, METH_VARARGS, NULL},
48498 : { (char *)"scalebarObj_units_get", _wrap_scalebarObj_units_get, METH_VARARGS, NULL},
48499 : { (char *)"scalebarObj_status_set", _wrap_scalebarObj_status_set, METH_VARARGS, NULL},
48500 : { (char *)"scalebarObj_status_get", _wrap_scalebarObj_status_get, METH_VARARGS, NULL},
48501 : { (char *)"scalebarObj_position_set", _wrap_scalebarObj_position_set, METH_VARARGS, NULL},
48502 : { (char *)"scalebarObj_position_get", _wrap_scalebarObj_position_get, METH_VARARGS, NULL},
48503 : { (char *)"scalebarObj_postlabelcache_set", _wrap_scalebarObj_postlabelcache_set, METH_VARARGS, NULL},
48504 : { (char *)"scalebarObj_postlabelcache_get", _wrap_scalebarObj_postlabelcache_get, METH_VARARGS, NULL},
48505 : { (char *)"scalebarObj_align_set", _wrap_scalebarObj_align_set, METH_VARARGS, NULL},
48506 : { (char *)"scalebarObj_align_get", _wrap_scalebarObj_align_get, METH_VARARGS, NULL},
48507 : { (char *)"scalebarObj_offsetx_set", _wrap_scalebarObj_offsetx_set, METH_VARARGS, NULL},
48508 : { (char *)"scalebarObj_offsetx_get", _wrap_scalebarObj_offsetx_get, METH_VARARGS, NULL},
48509 : { (char *)"scalebarObj_offsety_set", _wrap_scalebarObj_offsety_set, METH_VARARGS, NULL},
48510 : { (char *)"scalebarObj_offsety_get", _wrap_scalebarObj_offsety_get, METH_VARARGS, NULL},
48511 : { (char *)"scalebarObj_updateFromString", _wrap_scalebarObj_updateFromString, METH_VARARGS, NULL},
48512 : { (char *)"scalebarObj_convertToString", _wrap_scalebarObj_convertToString, METH_VARARGS, NULL},
48513 : { (char *)"new_scalebarObj", _wrap_new_scalebarObj, METH_VARARGS, NULL},
48514 : { (char *)"delete_scalebarObj", _wrap_delete_scalebarObj, METH_VARARGS, NULL},
48515 : { (char *)"scalebarObj_swigregister", scalebarObj_swigregister, METH_VARARGS, NULL},
48516 : { (char *)"legendObj_imagecolor_set", _wrap_legendObj_imagecolor_set, METH_VARARGS, NULL},
48517 : { (char *)"legendObj_imagecolor_get", _wrap_legendObj_imagecolor_get, METH_VARARGS, NULL},
48518 : { (char *)"legendObj_label_get", _wrap_legendObj_label_get, METH_VARARGS, NULL},
48519 : { (char *)"legendObj_keysizex_set", _wrap_legendObj_keysizex_set, METH_VARARGS, NULL},
48520 : { (char *)"legendObj_keysizex_get", _wrap_legendObj_keysizex_get, METH_VARARGS, NULL},
48521 : { (char *)"legendObj_keysizey_set", _wrap_legendObj_keysizey_set, METH_VARARGS, NULL},
48522 : { (char *)"legendObj_keysizey_get", _wrap_legendObj_keysizey_get, METH_VARARGS, NULL},
48523 : { (char *)"legendObj_keyspacingx_set", _wrap_legendObj_keyspacingx_set, METH_VARARGS, NULL},
48524 : { (char *)"legendObj_keyspacingx_get", _wrap_legendObj_keyspacingx_get, METH_VARARGS, NULL},
48525 : { (char *)"legendObj_keyspacingy_set", _wrap_legendObj_keyspacingy_set, METH_VARARGS, NULL},
48526 : { (char *)"legendObj_keyspacingy_get", _wrap_legendObj_keyspacingy_get, METH_VARARGS, NULL},
48527 : { (char *)"legendObj_outlinecolor_set", _wrap_legendObj_outlinecolor_set, METH_VARARGS, NULL},
48528 : { (char *)"legendObj_outlinecolor_get", _wrap_legendObj_outlinecolor_get, METH_VARARGS, NULL},
48529 : { (char *)"legendObj_status_set", _wrap_legendObj_status_set, METH_VARARGS, NULL},
48530 : { (char *)"legendObj_status_get", _wrap_legendObj_status_get, METH_VARARGS, NULL},
48531 : { (char *)"legendObj_height_set", _wrap_legendObj_height_set, METH_VARARGS, NULL},
48532 : { (char *)"legendObj_height_get", _wrap_legendObj_height_get, METH_VARARGS, NULL},
48533 : { (char *)"legendObj_width_set", _wrap_legendObj_width_set, METH_VARARGS, NULL},
48534 : { (char *)"legendObj_width_get", _wrap_legendObj_width_get, METH_VARARGS, NULL},
48535 : { (char *)"legendObj_position_set", _wrap_legendObj_position_set, METH_VARARGS, NULL},
48536 : { (char *)"legendObj_position_get", _wrap_legendObj_position_get, METH_VARARGS, NULL},
48537 : { (char *)"legendObj_postlabelcache_set", _wrap_legendObj_postlabelcache_set, METH_VARARGS, NULL},
48538 : { (char *)"legendObj_postlabelcache_get", _wrap_legendObj_postlabelcache_get, METH_VARARGS, NULL},
48539 : { (char *)"legendObj_template_set", _wrap_legendObj_template_set, METH_VARARGS, NULL},
48540 : { (char *)"legendObj_template_get", _wrap_legendObj_template_get, METH_VARARGS, NULL},
48541 : { (char *)"legendObj_map_get", _wrap_legendObj_map_get, METH_VARARGS, NULL},
48542 : { (char *)"legendObj_updateFromString", _wrap_legendObj_updateFromString, METH_VARARGS, NULL},
48543 : { (char *)"legendObj_convertToString", _wrap_legendObj_convertToString, METH_VARARGS, NULL},
48544 : { (char *)"new_legendObj", _wrap_new_legendObj, METH_VARARGS, NULL},
48545 : { (char *)"delete_legendObj", _wrap_delete_legendObj, METH_VARARGS, NULL},
48546 : { (char *)"legendObj_swigregister", legendObj_swigregister, METH_VARARGS, NULL},
48547 : { (char *)"imageObj_width_get", _wrap_imageObj_width_get, METH_VARARGS, NULL},
48548 : { (char *)"imageObj_height_get", _wrap_imageObj_height_get, METH_VARARGS, NULL},
48549 : { (char *)"imageObj_resolution_get", _wrap_imageObj_resolution_get, METH_VARARGS, NULL},
48550 : { (char *)"imageObj_resolutionfactor_get", _wrap_imageObj_resolutionfactor_get, METH_VARARGS, NULL},
48551 : { (char *)"imageObj_imagepath_get", _wrap_imageObj_imagepath_get, METH_VARARGS, NULL},
48552 : { (char *)"imageObj_imageurl_get", _wrap_imageObj_imageurl_get, METH_VARARGS, NULL},
48553 : { (char *)"imageObj_format_get", _wrap_imageObj_format_get, METH_VARARGS, NULL},
48554 : { (char *)"new_imageObj", _wrap_new_imageObj, METH_VARARGS, NULL},
48555 : { (char *)"delete_imageObj", _wrap_delete_imageObj, METH_VARARGS, NULL},
48556 : { (char *)"imageObj_save", _wrap_imageObj_save, METH_VARARGS, NULL},
48557 : { (char *)"imageObj_getBytes", _wrap_imageObj_getBytes, METH_VARARGS, NULL},
48558 : { (char *)"imageObj_getSize", _wrap_imageObj_getSize, METH_VARARGS, NULL},
48559 : { (char *)"imageObj_write", _wrap_imageObj_write, METH_VARARGS, NULL},
48560 : { (char *)"imageObj_saveToString", _wrap_imageObj_saveToString, METH_VARARGS, NULL},
48561 : { (char *)"imageObj_swigregister", imageObj_swigregister, METH_VARARGS, NULL},
48562 : { (char *)"scaleTokenEntryObj_minscale_set", _wrap_scaleTokenEntryObj_minscale_set, METH_VARARGS, NULL},
48563 : { (char *)"scaleTokenEntryObj_minscale_get", _wrap_scaleTokenEntryObj_minscale_get, METH_VARARGS, NULL},
48564 : { (char *)"scaleTokenEntryObj_maxscale_set", _wrap_scaleTokenEntryObj_maxscale_set, METH_VARARGS, NULL},
48565 : { (char *)"scaleTokenEntryObj_maxscale_get", _wrap_scaleTokenEntryObj_maxscale_get, METH_VARARGS, NULL},
48566 : { (char *)"scaleTokenEntryObj_value_set", _wrap_scaleTokenEntryObj_value_set, METH_VARARGS, NULL},
48567 : { (char *)"scaleTokenEntryObj_value_get", _wrap_scaleTokenEntryObj_value_get, METH_VARARGS, NULL},
48568 : { (char *)"new_scaleTokenEntryObj", _wrap_new_scaleTokenEntryObj, METH_VARARGS, NULL},
48569 : { (char *)"delete_scaleTokenEntryObj", _wrap_delete_scaleTokenEntryObj, METH_VARARGS, NULL},
48570 : { (char *)"scaleTokenEntryObj_swigregister", scaleTokenEntryObj_swigregister, METH_VARARGS, NULL},
48571 : { (char *)"scaleTokenObj_name_set", _wrap_scaleTokenObj_name_set, METH_VARARGS, NULL},
48572 : { (char *)"scaleTokenObj_name_get", _wrap_scaleTokenObj_name_get, METH_VARARGS, NULL},
48573 : { (char *)"scaleTokenObj_n_entries_set", _wrap_scaleTokenObj_n_entries_set, METH_VARARGS, NULL},
48574 : { (char *)"scaleTokenObj_n_entries_get", _wrap_scaleTokenObj_n_entries_get, METH_VARARGS, NULL},
48575 : { (char *)"scaleTokenObj_tokens_set", _wrap_scaleTokenObj_tokens_set, METH_VARARGS, NULL},
48576 : { (char *)"scaleTokenObj_tokens_get", _wrap_scaleTokenObj_tokens_get, METH_VARARGS, NULL},
48577 : { (char *)"new_scaleTokenObj", _wrap_new_scaleTokenObj, METH_VARARGS, NULL},
48578 : { (char *)"delete_scaleTokenObj", _wrap_delete_scaleTokenObj, METH_VARARGS, NULL},
48579 : { (char *)"scaleTokenObj_swigregister", scaleTokenObj_swigregister, METH_VARARGS, NULL},
48580 : { (char *)"layerObj_classitem_set", _wrap_layerObj_classitem_set, METH_VARARGS, NULL},
48581 : { (char *)"layerObj_classitem_get", _wrap_layerObj_classitem_get, METH_VARARGS, NULL},
48582 : { (char *)"layerObj_refcount_get", _wrap_layerObj_refcount_get, METH_VARARGS, NULL},
48583 : { (char *)"layerObj_numclasses_get", _wrap_layerObj_numclasses_get, METH_VARARGS, NULL},
48584 : { (char *)"layerObj_maxclasses_get", _wrap_layerObj_maxclasses_get, METH_VARARGS, NULL},
48585 : { (char *)"layerObj_index_get", _wrap_layerObj_index_get, METH_VARARGS, NULL},
48586 : { (char *)"layerObj_map_get", _wrap_layerObj_map_get, METH_VARARGS, NULL},
48587 : { (char *)"layerObj_header_set", _wrap_layerObj_header_set, METH_VARARGS, NULL},
48588 : { (char *)"layerObj_header_get", _wrap_layerObj_header_get, METH_VARARGS, NULL},
48589 : { (char *)"layerObj_footer_set", _wrap_layerObj_footer_set, METH_VARARGS, NULL},
48590 : { (char *)"layerObj_footer_get", _wrap_layerObj_footer_get, METH_VARARGS, NULL},
48591 : { (char *)"layerObj_template_set", _wrap_layerObj_template_set, METH_VARARGS, NULL},
48592 : { (char *)"layerObj_template_get", _wrap_layerObj_template_get, METH_VARARGS, NULL},
48593 : { (char *)"layerObj_name_set", _wrap_layerObj_name_set, METH_VARARGS, NULL},
48594 : { (char *)"layerObj_name_get", _wrap_layerObj_name_get, METH_VARARGS, NULL},
48595 : { (char *)"layerObj_group_set", _wrap_layerObj_group_set, METH_VARARGS, NULL},
48596 : { (char *)"layerObj_group_get", _wrap_layerObj_group_get, METH_VARARGS, NULL},
48597 : { (char *)"layerObj_status_set", _wrap_layerObj_status_set, METH_VARARGS, NULL},
48598 : { (char *)"layerObj_status_get", _wrap_layerObj_status_get, METH_VARARGS, NULL},
48599 : { (char *)"layerObj_rendermode_set", _wrap_layerObj_rendermode_set, METH_VARARGS, NULL},
48600 : { (char *)"layerObj_rendermode_get", _wrap_layerObj_rendermode_get, METH_VARARGS, NULL},
48601 : { (char *)"layerObj_data_set", _wrap_layerObj_data_set, METH_VARARGS, NULL},
48602 : { (char *)"layerObj_data_get", _wrap_layerObj_data_get, METH_VARARGS, NULL},
48603 : { (char *)"layerObj_type_set", _wrap_layerObj_type_set, METH_VARARGS, NULL},
48604 : { (char *)"layerObj_type_get", _wrap_layerObj_type_get, METH_VARARGS, NULL},
48605 : { (char *)"layerObj_tolerance_set", _wrap_layerObj_tolerance_set, METH_VARARGS, NULL},
48606 : { (char *)"layerObj_tolerance_get", _wrap_layerObj_tolerance_get, METH_VARARGS, NULL},
48607 : { (char *)"layerObj_toleranceunits_set", _wrap_layerObj_toleranceunits_set, METH_VARARGS, NULL},
48608 : { (char *)"layerObj_toleranceunits_get", _wrap_layerObj_toleranceunits_get, METH_VARARGS, NULL},
48609 : { (char *)"layerObj_symbolscaledenom_set", _wrap_layerObj_symbolscaledenom_set, METH_VARARGS, NULL},
48610 : { (char *)"layerObj_symbolscaledenom_get", _wrap_layerObj_symbolscaledenom_get, METH_VARARGS, NULL},
48611 : { (char *)"layerObj_minscaledenom_set", _wrap_layerObj_minscaledenom_set, METH_VARARGS, NULL},
48612 : { (char *)"layerObj_minscaledenom_get", _wrap_layerObj_minscaledenom_get, METH_VARARGS, NULL},
48613 : { (char *)"layerObj_maxscaledenom_set", _wrap_layerObj_maxscaledenom_set, METH_VARARGS, NULL},
48614 : { (char *)"layerObj_maxscaledenom_get", _wrap_layerObj_maxscaledenom_get, METH_VARARGS, NULL},
48615 : { (char *)"layerObj_minfeaturesize_set", _wrap_layerObj_minfeaturesize_set, METH_VARARGS, NULL},
48616 : { (char *)"layerObj_minfeaturesize_get", _wrap_layerObj_minfeaturesize_get, METH_VARARGS, NULL},
48617 : { (char *)"layerObj_labelminscaledenom_set", _wrap_layerObj_labelminscaledenom_set, METH_VARARGS, NULL},
48618 : { (char *)"layerObj_labelminscaledenom_get", _wrap_layerObj_labelminscaledenom_get, METH_VARARGS, NULL},
48619 : { (char *)"layerObj_labelmaxscaledenom_set", _wrap_layerObj_labelmaxscaledenom_set, METH_VARARGS, NULL},
48620 : { (char *)"layerObj_labelmaxscaledenom_get", _wrap_layerObj_labelmaxscaledenom_get, METH_VARARGS, NULL},
48621 : { (char *)"layerObj_mingeowidth_set", _wrap_layerObj_mingeowidth_set, METH_VARARGS, NULL},
48622 : { (char *)"layerObj_mingeowidth_get", _wrap_layerObj_mingeowidth_get, METH_VARARGS, NULL},
48623 : { (char *)"layerObj_maxgeowidth_set", _wrap_layerObj_maxgeowidth_set, METH_VARARGS, NULL},
48624 : { (char *)"layerObj_maxgeowidth_get", _wrap_layerObj_maxgeowidth_get, METH_VARARGS, NULL},
48625 : { (char *)"layerObj_sizeunits_set", _wrap_layerObj_sizeunits_set, METH_VARARGS, NULL},
48626 : { (char *)"layerObj_sizeunits_get", _wrap_layerObj_sizeunits_get, METH_VARARGS, NULL},
48627 : { (char *)"layerObj_maxfeatures_set", _wrap_layerObj_maxfeatures_set, METH_VARARGS, NULL},
48628 : { (char *)"layerObj_maxfeatures_get", _wrap_layerObj_maxfeatures_get, METH_VARARGS, NULL},
48629 : { (char *)"layerObj_startindex_set", _wrap_layerObj_startindex_set, METH_VARARGS, NULL},
48630 : { (char *)"layerObj_startindex_get", _wrap_layerObj_startindex_get, METH_VARARGS, NULL},
48631 : { (char *)"layerObj_offsite_set", _wrap_layerObj_offsite_set, METH_VARARGS, NULL},
48632 : { (char *)"layerObj_offsite_get", _wrap_layerObj_offsite_get, METH_VARARGS, NULL},
48633 : { (char *)"layerObj_transform_set", _wrap_layerObj_transform_set, METH_VARARGS, NULL},
48634 : { (char *)"layerObj_transform_get", _wrap_layerObj_transform_get, METH_VARARGS, NULL},
48635 : { (char *)"layerObj_labelcache_set", _wrap_layerObj_labelcache_set, METH_VARARGS, NULL},
48636 : { (char *)"layerObj_labelcache_get", _wrap_layerObj_labelcache_get, METH_VARARGS, NULL},
48637 : { (char *)"layerObj_postlabelcache_set", _wrap_layerObj_postlabelcache_set, METH_VARARGS, NULL},
48638 : { (char *)"layerObj_postlabelcache_get", _wrap_layerObj_postlabelcache_get, METH_VARARGS, NULL},
48639 : { (char *)"layerObj_labelitem_set", _wrap_layerObj_labelitem_set, METH_VARARGS, NULL},
48640 : { (char *)"layerObj_labelitem_get", _wrap_layerObj_labelitem_get, METH_VARARGS, NULL},
48641 : { (char *)"layerObj_tileitem_set", _wrap_layerObj_tileitem_set, METH_VARARGS, NULL},
48642 : { (char *)"layerObj_tileitem_get", _wrap_layerObj_tileitem_get, METH_VARARGS, NULL},
48643 : { (char *)"layerObj_tileindex_set", _wrap_layerObj_tileindex_set, METH_VARARGS, NULL},
48644 : { (char *)"layerObj_tileindex_get", _wrap_layerObj_tileindex_get, METH_VARARGS, NULL},
48645 : { (char *)"layerObj_tilesrs_set", _wrap_layerObj_tilesrs_set, METH_VARARGS, NULL},
48646 : { (char *)"layerObj_tilesrs_get", _wrap_layerObj_tilesrs_get, METH_VARARGS, NULL},
48647 : { (char *)"layerObj_units_set", _wrap_layerObj_units_set, METH_VARARGS, NULL},
48648 : { (char *)"layerObj_units_get", _wrap_layerObj_units_get, METH_VARARGS, NULL},
48649 : { (char *)"layerObj_connection_set", _wrap_layerObj_connection_set, METH_VARARGS, NULL},
48650 : { (char *)"layerObj_connection_get", _wrap_layerObj_connection_get, METH_VARARGS, NULL},
48651 : { (char *)"layerObj_plugin_library_set", _wrap_layerObj_plugin_library_set, METH_VARARGS, NULL},
48652 : { (char *)"layerObj_plugin_library_get", _wrap_layerObj_plugin_library_get, METH_VARARGS, NULL},
48653 : { (char *)"layerObj_plugin_library_original_set", _wrap_layerObj_plugin_library_original_set, METH_VARARGS, NULL},
48654 : { (char *)"layerObj_plugin_library_original_get", _wrap_layerObj_plugin_library_original_get, METH_VARARGS, NULL},
48655 : { (char *)"layerObj_connectiontype_set", _wrap_layerObj_connectiontype_set, METH_VARARGS, NULL},
48656 : { (char *)"layerObj_connectiontype_get", _wrap_layerObj_connectiontype_get, METH_VARARGS, NULL},
48657 : { (char *)"layerObj_numitems_get", _wrap_layerObj_numitems_get, METH_VARARGS, NULL},
48658 : { (char *)"layerObj_bandsitem_set", _wrap_layerObj_bandsitem_set, METH_VARARGS, NULL},
48659 : { (char *)"layerObj_bandsitem_get", _wrap_layerObj_bandsitem_get, METH_VARARGS, NULL},
48660 : { (char *)"layerObj_filteritem_set", _wrap_layerObj_filteritem_set, METH_VARARGS, NULL},
48661 : { (char *)"layerObj_filteritem_get", _wrap_layerObj_filteritem_get, METH_VARARGS, NULL},
48662 : { (char *)"layerObj_styleitem_set", _wrap_layerObj_styleitem_set, METH_VARARGS, NULL},
48663 : { (char *)"layerObj_styleitem_get", _wrap_layerObj_styleitem_get, METH_VARARGS, NULL},
48664 : { (char *)"layerObj_requires_set", _wrap_layerObj_requires_set, METH_VARARGS, NULL},
48665 : { (char *)"layerObj_requires_get", _wrap_layerObj_requires_get, METH_VARARGS, NULL},
48666 : { (char *)"layerObj_labelrequires_set", _wrap_layerObj_labelrequires_set, METH_VARARGS, NULL},
48667 : { (char *)"layerObj_labelrequires_get", _wrap_layerObj_labelrequires_get, METH_VARARGS, NULL},
48668 : { (char *)"layerObj_metadata_get", _wrap_layerObj_metadata_get, METH_VARARGS, NULL},
48669 : { (char *)"layerObj_validation_get", _wrap_layerObj_validation_get, METH_VARARGS, NULL},
48670 : { (char *)"layerObj_bindvals_get", _wrap_layerObj_bindvals_get, METH_VARARGS, NULL},
48671 : { (char *)"layerObj_cluster_get", _wrap_layerObj_cluster_get, METH_VARARGS, NULL},
48672 : { (char *)"layerObj_dump_set", _wrap_layerObj_dump_set, METH_VARARGS, NULL},
48673 : { (char *)"layerObj_dump_get", _wrap_layerObj_dump_get, METH_VARARGS, NULL},
48674 : { (char *)"layerObj_debug_set", _wrap_layerObj_debug_set, METH_VARARGS, NULL},
48675 : { (char *)"layerObj_debug_get", _wrap_layerObj_debug_get, METH_VARARGS, NULL},
48676 : { (char *)"layerObj_extent_get", _wrap_layerObj_extent_get, METH_VARARGS, NULL},
48677 : { (char *)"layerObj_numprocessing_get", _wrap_layerObj_numprocessing_get, METH_VARARGS, NULL},
48678 : { (char *)"layerObj_numjoins_get", _wrap_layerObj_numjoins_get, METH_VARARGS, NULL},
48679 : { (char *)"layerObj_classgroup_set", _wrap_layerObj_classgroup_set, METH_VARARGS, NULL},
48680 : { (char *)"layerObj_classgroup_get", _wrap_layerObj_classgroup_get, METH_VARARGS, NULL},
48681 : { (char *)"layerObj_mask_set", _wrap_layerObj_mask_set, METH_VARARGS, NULL},
48682 : { (char *)"layerObj_mask_get", _wrap_layerObj_mask_get, METH_VARARGS, NULL},
48683 : { (char *)"layerObj_encoding_set", _wrap_layerObj_encoding_set, METH_VARARGS, NULL},
48684 : { (char *)"layerObj_encoding_get", _wrap_layerObj_encoding_get, METH_VARARGS, NULL},
48685 : { (char *)"layerObj_utfitem_set", _wrap_layerObj_utfitem_set, METH_VARARGS, NULL},
48686 : { (char *)"layerObj_utfitem_get", _wrap_layerObj_utfitem_get, METH_VARARGS, NULL},
48687 : { (char *)"layerObj_utfitemindex_set", _wrap_layerObj_utfitemindex_set, METH_VARARGS, NULL},
48688 : { (char *)"layerObj_utfitemindex_get", _wrap_layerObj_utfitemindex_get, METH_VARARGS, NULL},
48689 : { (char *)"layerObj_utfdata_set", _wrap_layerObj_utfdata_set, METH_VARARGS, NULL},
48690 : { (char *)"layerObj_utfdata_get", _wrap_layerObj_utfdata_get, METH_VARARGS, NULL},
48691 : { (char *)"layerObj_compositer_set", _wrap_layerObj_compositer_set, METH_VARARGS, NULL},
48692 : { (char *)"layerObj_compositer_get", _wrap_layerObj_compositer_get, METH_VARARGS, NULL},
48693 : { (char *)"layerObj_connectionoptions_set", _wrap_layerObj_connectionoptions_set, METH_VARARGS, NULL},
48694 : { (char *)"layerObj_connectionoptions_get", _wrap_layerObj_connectionoptions_get, METH_VARARGS, NULL},
48695 : { (char *)"new_layerObj", _wrap_new_layerObj, METH_VARARGS, NULL},
48696 : { (char *)"layerObj_setOpacity", _wrap_layerObj_setOpacity, METH_VARARGS, NULL},
48697 : { (char *)"layerObj_getOpacity", _wrap_layerObj_getOpacity, METH_VARARGS, NULL},
48698 : { (char *)"delete_layerObj", _wrap_delete_layerObj, METH_VARARGS, NULL},
48699 : { (char *)"layerObj_clone", _wrap_layerObj_clone, METH_VARARGS, NULL},
48700 : { (char *)"layerObj_updateFromString", _wrap_layerObj_updateFromString, METH_VARARGS, NULL},
48701 : { (char *)"layerObj_convertToString", _wrap_layerObj_convertToString, METH_VARARGS, NULL},
48702 : { (char *)"layerObj_insertClass", _wrap_layerObj_insertClass, METH_VARARGS, NULL},
48703 : { (char *)"layerObj_removeClass", _wrap_layerObj_removeClass, METH_VARARGS, NULL},
48704 : { (char *)"layerObj_open", _wrap_layerObj_open, METH_VARARGS, NULL},
48705 : { (char *)"layerObj_whichShapes", _wrap_layerObj_whichShapes, METH_VARARGS, NULL},
48706 : { (char *)"layerObj_nextShape", _wrap_layerObj_nextShape, METH_VARARGS, NULL},
48707 : { (char *)"layerObj_close", _wrap_layerObj_close, METH_VARARGS, NULL},
48708 : { (char *)"layerObj_getShape", _wrap_layerObj_getShape, METH_VARARGS, NULL},
48709 : { (char *)"layerObj_getNumResults", _wrap_layerObj_getNumResults, METH_VARARGS, NULL},
48710 : { (char *)"layerObj_getResultsBounds", _wrap_layerObj_getResultsBounds, METH_VARARGS, NULL},
48711 : { (char *)"layerObj_getResult", _wrap_layerObj_getResult, METH_VARARGS, NULL},
48712 : { (char *)"layerObj_getClass", _wrap_layerObj_getClass, METH_VARARGS, NULL},
48713 : { (char *)"layerObj_getItem", _wrap_layerObj_getItem, METH_VARARGS, NULL},
48714 : { (char *)"layerObj_setItems", _wrap_layerObj_setItems, METH_VARARGS, NULL},
48715 : { (char *)"layerObj_draw", _wrap_layerObj_draw, METH_VARARGS, NULL},
48716 : { (char *)"layerObj_drawQuery", _wrap_layerObj_drawQuery, METH_VARARGS, NULL},
48717 : { (char *)"layerObj_queryByFilter", _wrap_layerObj_queryByFilter, METH_VARARGS, NULL},
48718 : { (char *)"layerObj_queryByAttributes", _wrap_layerObj_queryByAttributes, METH_VARARGS, NULL},
48719 : { (char *)"layerObj_queryByPoint", _wrap_layerObj_queryByPoint, METH_VARARGS, NULL},
48720 : { (char *)"layerObj_queryByRect", _wrap_layerObj_queryByRect, METH_VARARGS, NULL},
48721 : { (char *)"layerObj_queryByFeatures", _wrap_layerObj_queryByFeatures, METH_VARARGS, NULL},
48722 : { (char *)"layerObj_queryByShape", _wrap_layerObj_queryByShape, METH_VARARGS, NULL},
48723 : { (char *)"layerObj_queryByIndex", _wrap_layerObj_queryByIndex, METH_VARARGS, NULL},
48724 : { (char *)"layerObj_getResults", _wrap_layerObj_getResults, METH_VARARGS, NULL},
48725 : { (char *)"layerObj_setFilter", _wrap_layerObj_setFilter, METH_VARARGS, NULL},
48726 : { (char *)"layerObj_getFilterString", _wrap_layerObj_getFilterString, METH_VARARGS, NULL},
48727 : { (char *)"layerObj_setWKTProjection", _wrap_layerObj_setWKTProjection, METH_VARARGS, NULL},
48728 : { (char *)"layerObj_getProjection", _wrap_layerObj_getProjection, METH_VARARGS, NULL},
48729 : { (char *)"layerObj_setProjection", _wrap_layerObj_setProjection, METH_VARARGS, NULL},
48730 : { (char *)"layerObj_addFeature", _wrap_layerObj_addFeature, METH_VARARGS, NULL},
48731 : { (char *)"layerObj_getNumFeatures", _wrap_layerObj_getNumFeatures, METH_VARARGS, NULL},
48732 : { (char *)"layerObj_getExtent", _wrap_layerObj_getExtent, METH_VARARGS, NULL},
48733 : { (char *)"layerObj_setExtent", _wrap_layerObj_setExtent, METH_VARARGS, NULL},
48734 : { (char *)"layerObj_getMetaData", _wrap_layerObj_getMetaData, METH_VARARGS, NULL},
48735 : { (char *)"layerObj_setMetaData", _wrap_layerObj_setMetaData, METH_VARARGS, NULL},
48736 : { (char *)"layerObj_removeMetaData", _wrap_layerObj_removeMetaData, METH_VARARGS, NULL},
48737 : { (char *)"layerObj_getFirstMetaDataKey", _wrap_layerObj_getFirstMetaDataKey, METH_VARARGS, NULL},
48738 : { (char *)"layerObj_getNextMetaDataKey", _wrap_layerObj_getNextMetaDataKey, METH_VARARGS, NULL},
48739 : { (char *)"layerObj_getWMSFeatureInfoURL", _wrap_layerObj_getWMSFeatureInfoURL, METH_VARARGS, NULL},
48740 : { (char *)"layerObj_executeWFSGetFeature", _wrap_layerObj_executeWFSGetFeature, METH_VARARGS, NULL},
48741 : { (char *)"layerObj_applySLD", _wrap_layerObj_applySLD, METH_VARARGS, NULL},
48742 : { (char *)"layerObj_applySLDURL", _wrap_layerObj_applySLDURL, METH_VARARGS, NULL},
48743 : { (char *)"layerObj_generateSLD", _wrap_layerObj_generateSLD, METH_VARARGS, NULL},
48744 : { (char *)"layerObj_isVisible", _wrap_layerObj_isVisible, METH_VARARGS, NULL},
48745 : { (char *)"layerObj_moveClassUp", _wrap_layerObj_moveClassUp, METH_VARARGS, NULL},
48746 : { (char *)"layerObj_moveClassDown", _wrap_layerObj_moveClassDown, METH_VARARGS, NULL},
48747 : { (char *)"layerObj_setProcessingKey", _wrap_layerObj_setProcessingKey, METH_VARARGS, NULL},
48748 : { (char *)"layerObj_setProcessing", _wrap_layerObj_setProcessing, METH_VARARGS, NULL},
48749 : { (char *)"layerObj_addProcessing", _wrap_layerObj_addProcessing, METH_VARARGS, NULL},
48750 : { (char *)"layerObj_getProcessing", _wrap_layerObj_getProcessing, METH_VARARGS, NULL},
48751 : { (char *)"layerObj_getProcessingKey", _wrap_layerObj_getProcessingKey, METH_VARARGS, NULL},
48752 : { (char *)"layerObj_clearProcessing", _wrap_layerObj_clearProcessing, METH_VARARGS, NULL},
48753 : { (char *)"layerObj_setConnectionType", _wrap_layerObj_setConnectionType, METH_VARARGS, NULL},
48754 : { (char *)"layerObj_getClassIndex", _wrap_layerObj_getClassIndex, METH_VARARGS, NULL},
48755 : { (char *)"layerObj_getGeomTransform", _wrap_layerObj_getGeomTransform, METH_VARARGS, NULL},
48756 : { (char *)"layerObj_setGeomTransform", _wrap_layerObj_setGeomTransform, METH_VARARGS, NULL},
48757 : { (char *)"layerObj_getItemType", _wrap_layerObj_getItemType, METH_VARARGS, NULL},
48758 : { (char *)"layerObj_swigregister", layerObj_swigregister, METH_VARARGS, NULL},
48759 : { (char *)"mapObj_name_set", _wrap_mapObj_name_set, METH_VARARGS, NULL},
48760 : { (char *)"mapObj_name_get", _wrap_mapObj_name_get, METH_VARARGS, NULL},
48761 : { (char *)"mapObj_status_set", _wrap_mapObj_status_set, METH_VARARGS, NULL},
48762 : { (char *)"mapObj_status_get", _wrap_mapObj_status_get, METH_VARARGS, NULL},
48763 : { (char *)"mapObj_height_set", _wrap_mapObj_height_set, METH_VARARGS, NULL},
48764 : { (char *)"mapObj_height_get", _wrap_mapObj_height_get, METH_VARARGS, NULL},
48765 : { (char *)"mapObj_width_set", _wrap_mapObj_width_set, METH_VARARGS, NULL},
48766 : { (char *)"mapObj_width_get", _wrap_mapObj_width_get, METH_VARARGS, NULL},
48767 : { (char *)"mapObj_maxsize_set", _wrap_mapObj_maxsize_set, METH_VARARGS, NULL},
48768 : { (char *)"mapObj_maxsize_get", _wrap_mapObj_maxsize_get, METH_VARARGS, NULL},
48769 : { (char *)"mapObj_refcount_get", _wrap_mapObj_refcount_get, METH_VARARGS, NULL},
48770 : { (char *)"mapObj_numlayers_get", _wrap_mapObj_numlayers_get, METH_VARARGS, NULL},
48771 : { (char *)"mapObj_maxlayers_get", _wrap_mapObj_maxlayers_get, METH_VARARGS, NULL},
48772 : { (char *)"mapObj_symbolset_get", _wrap_mapObj_symbolset_get, METH_VARARGS, NULL},
48773 : { (char *)"mapObj_fontset_get", _wrap_mapObj_fontset_get, METH_VARARGS, NULL},
48774 : { (char *)"mapObj_labelcache_get", _wrap_mapObj_labelcache_get, METH_VARARGS, NULL},
48775 : { (char *)"mapObj_transparent_set", _wrap_mapObj_transparent_set, METH_VARARGS, NULL},
48776 : { (char *)"mapObj_transparent_get", _wrap_mapObj_transparent_get, METH_VARARGS, NULL},
48777 : { (char *)"mapObj_interlace_set", _wrap_mapObj_interlace_set, METH_VARARGS, NULL},
48778 : { (char *)"mapObj_interlace_get", _wrap_mapObj_interlace_get, METH_VARARGS, NULL},
48779 : { (char *)"mapObj_imagequality_set", _wrap_mapObj_imagequality_set, METH_VARARGS, NULL},
48780 : { (char *)"mapObj_imagequality_get", _wrap_mapObj_imagequality_get, METH_VARARGS, NULL},
48781 : { (char *)"mapObj_extent_set", _wrap_mapObj_extent_set, METH_VARARGS, NULL},
48782 : { (char *)"mapObj_extent_get", _wrap_mapObj_extent_get, METH_VARARGS, NULL},
48783 : { (char *)"mapObj_cellsize_set", _wrap_mapObj_cellsize_set, METH_VARARGS, NULL},
48784 : { (char *)"mapObj_cellsize_get", _wrap_mapObj_cellsize_get, METH_VARARGS, NULL},
48785 : { (char *)"mapObj_units_set", _wrap_mapObj_units_set, METH_VARARGS, NULL},
48786 : { (char *)"mapObj_units_get", _wrap_mapObj_units_get, METH_VARARGS, NULL},
48787 : { (char *)"mapObj_scaledenom_set", _wrap_mapObj_scaledenom_set, METH_VARARGS, NULL},
48788 : { (char *)"mapObj_scaledenom_get", _wrap_mapObj_scaledenom_get, METH_VARARGS, NULL},
48789 : { (char *)"mapObj_resolution_set", _wrap_mapObj_resolution_set, METH_VARARGS, NULL},
48790 : { (char *)"mapObj_resolution_get", _wrap_mapObj_resolution_get, METH_VARARGS, NULL},
48791 : { (char *)"mapObj_defresolution_set", _wrap_mapObj_defresolution_set, METH_VARARGS, NULL},
48792 : { (char *)"mapObj_defresolution_get", _wrap_mapObj_defresolution_get, METH_VARARGS, NULL},
48793 : { (char *)"mapObj_shapepath_set", _wrap_mapObj_shapepath_set, METH_VARARGS, NULL},
48794 : { (char *)"mapObj_shapepath_get", _wrap_mapObj_shapepath_get, METH_VARARGS, NULL},
48795 : { (char *)"mapObj_mappath_set", _wrap_mapObj_mappath_set, METH_VARARGS, NULL},
48796 : { (char *)"mapObj_mappath_get", _wrap_mapObj_mappath_get, METH_VARARGS, NULL},
48797 : { (char *)"mapObj_sldurl_set", _wrap_mapObj_sldurl_set, METH_VARARGS, NULL},
48798 : { (char *)"mapObj_sldurl_get", _wrap_mapObj_sldurl_get, METH_VARARGS, NULL},
48799 : { (char *)"mapObj_imagecolor_set", _wrap_mapObj_imagecolor_set, METH_VARARGS, NULL},
48800 : { (char *)"mapObj_imagecolor_get", _wrap_mapObj_imagecolor_get, METH_VARARGS, NULL},
48801 : { (char *)"mapObj_numoutputformats_get", _wrap_mapObj_numoutputformats_get, METH_VARARGS, NULL},
48802 : { (char *)"mapObj_outputformat_get", _wrap_mapObj_outputformat_get, METH_VARARGS, NULL},
48803 : { (char *)"mapObj_imagetype_get", _wrap_mapObj_imagetype_get, METH_VARARGS, NULL},
48804 : { (char *)"mapObj_reference_get", _wrap_mapObj_reference_get, METH_VARARGS, NULL},
48805 : { (char *)"mapObj_scalebar_get", _wrap_mapObj_scalebar_get, METH_VARARGS, NULL},
48806 : { (char *)"mapObj_legend_get", _wrap_mapObj_legend_get, METH_VARARGS, NULL},
48807 : { (char *)"mapObj_querymap_get", _wrap_mapObj_querymap_get, METH_VARARGS, NULL},
48808 : { (char *)"mapObj_web_get", _wrap_mapObj_web_get, METH_VARARGS, NULL},
48809 : { (char *)"mapObj_layerorder_set", _wrap_mapObj_layerorder_set, METH_VARARGS, NULL},
48810 : { (char *)"mapObj_layerorder_get", _wrap_mapObj_layerorder_get, METH_VARARGS, NULL},
48811 : { (char *)"mapObj_debug_set", _wrap_mapObj_debug_set, METH_VARARGS, NULL},
48812 : { (char *)"mapObj_debug_get", _wrap_mapObj_debug_get, METH_VARARGS, NULL},
48813 : { (char *)"mapObj_datapattern_set", _wrap_mapObj_datapattern_set, METH_VARARGS, NULL},
48814 : { (char *)"mapObj_datapattern_get", _wrap_mapObj_datapattern_get, METH_VARARGS, NULL},
48815 : { (char *)"mapObj_templatepattern_set", _wrap_mapObj_templatepattern_set, METH_VARARGS, NULL},
48816 : { (char *)"mapObj_templatepattern_get", _wrap_mapObj_templatepattern_get, METH_VARARGS, NULL},
48817 : { (char *)"mapObj_configoptions_get", _wrap_mapObj_configoptions_get, METH_VARARGS, NULL},
48818 : { (char *)"new_mapObj", _wrap_new_mapObj, METH_VARARGS, NULL},
48819 : { (char *)"delete_mapObj", _wrap_delete_mapObj, METH_VARARGS, NULL},
48820 : { (char *)"mapObj_clone", _wrap_mapObj_clone, METH_VARARGS, NULL},
48821 : { (char *)"mapObj_insertLayer", _wrap_mapObj_insertLayer, METH_VARARGS, NULL},
48822 : { (char *)"mapObj_removeLayer", _wrap_mapObj_removeLayer, METH_VARARGS, NULL},
48823 : { (char *)"mapObj_setExtent", _wrap_mapObj_setExtent, METH_VARARGS, NULL},
48824 : { (char *)"mapObj_offsetExtent", _wrap_mapObj_offsetExtent, METH_VARARGS, NULL},
48825 : { (char *)"mapObj_scaleExtent", _wrap_mapObj_scaleExtent, METH_VARARGS, NULL},
48826 : { (char *)"mapObj_setCenter", _wrap_mapObj_setCenter, METH_VARARGS, NULL},
48827 : { (char *)"mapObj_setSize", _wrap_mapObj_setSize, METH_VARARGS, NULL},
48828 : { (char *)"mapObj_pixelToGeoref", _wrap_mapObj_pixelToGeoref, METH_VARARGS, NULL},
48829 : { (char *)"mapObj_getRotation", _wrap_mapObj_getRotation, METH_VARARGS, NULL},
48830 : { (char *)"mapObj_setRotation", _wrap_mapObj_setRotation, METH_VARARGS, NULL},
48831 : { (char *)"mapObj_getLayer", _wrap_mapObj_getLayer, METH_VARARGS, NULL},
48832 : { (char *)"mapObj_getLayerByName", _wrap_mapObj_getLayerByName, METH_VARARGS, NULL},
48833 : { (char *)"mapObj_getSymbolByName", _wrap_mapObj_getSymbolByName, METH_VARARGS, NULL},
48834 : { (char *)"mapObj_prepareQuery", _wrap_mapObj_prepareQuery, METH_VARARGS, NULL},
48835 : { (char *)"mapObj_prepareImage", _wrap_mapObj_prepareImage, METH_VARARGS, NULL},
48836 : { (char *)"mapObj_setImageType", _wrap_mapObj_setImageType, METH_VARARGS, NULL},
48837 : { (char *)"mapObj_selectOutputFormat", _wrap_mapObj_selectOutputFormat, METH_VARARGS, NULL},
48838 : { (char *)"mapObj_getOutputFormat", _wrap_mapObj_getOutputFormat, METH_VARARGS, NULL},
48839 : { (char *)"mapObj_setOutputFormat", _wrap_mapObj_setOutputFormat, METH_VARARGS, NULL},
48840 : { (char *)"mapObj_draw", _wrap_mapObj_draw, METH_VARARGS, NULL},
48841 : { (char *)"mapObj_drawQuery", _wrap_mapObj_drawQuery, METH_VARARGS, NULL},
48842 : { (char *)"mapObj_drawLegend", _wrap_mapObj_drawLegend, METH_VARARGS, NULL},
48843 : { (char *)"mapObj_drawScalebar", _wrap_mapObj_drawScalebar, METH_VARARGS, NULL},
48844 : { (char *)"mapObj_drawReferenceMap", _wrap_mapObj_drawReferenceMap, METH_VARARGS, NULL},
48845 : { (char *)"mapObj_embedScalebar", _wrap_mapObj_embedScalebar, METH_VARARGS, NULL},
48846 : { (char *)"mapObj_embedLegend", _wrap_mapObj_embedLegend, METH_VARARGS, NULL},
48847 : { (char *)"mapObj_drawLabelCache", _wrap_mapObj_drawLabelCache, METH_VARARGS, NULL},
48848 : { (char *)"mapObj_queryByFilter", _wrap_mapObj_queryByFilter, METH_VARARGS, NULL},
48849 : { (char *)"mapObj_queryByPoint", _wrap_mapObj_queryByPoint, METH_VARARGS, NULL},
48850 : { (char *)"mapObj_queryByRect", _wrap_mapObj_queryByRect, METH_VARARGS, NULL},
48851 : { (char *)"mapObj_queryByFeatures", _wrap_mapObj_queryByFeatures, METH_VARARGS, NULL},
48852 : { (char *)"mapObj_queryByShape", _wrap_mapObj_queryByShape, METH_VARARGS, NULL},
48853 : { (char *)"mapObj_setWKTProjection", _wrap_mapObj_setWKTProjection, METH_VARARGS, NULL},
48854 : { (char *)"mapObj_getProjection", _wrap_mapObj_getProjection, METH_VARARGS, NULL},
48855 : { (char *)"mapObj_setProjection", _wrap_mapObj_setProjection, METH_VARARGS, NULL},
48856 : { (char *)"mapObj_save", _wrap_mapObj_save, METH_VARARGS, NULL},
48857 : { (char *)"mapObj_saveQuery", _wrap_mapObj_saveQuery, METH_VARARGS, NULL},
48858 : { (char *)"mapObj_loadQuery", _wrap_mapObj_loadQuery, METH_VARARGS, NULL},
48859 : { (char *)"mapObj_freeQuery", _wrap_mapObj_freeQuery, METH_VARARGS, NULL},
48860 : { (char *)"mapObj_saveQueryAsGML", _wrap_mapObj_saveQueryAsGML, METH_VARARGS, NULL},
48861 : { (char *)"mapObj_getMetaData", _wrap_mapObj_getMetaData, METH_VARARGS, NULL},
48862 : { (char *)"mapObj_setMetaData", _wrap_mapObj_setMetaData, METH_VARARGS, NULL},
48863 : { (char *)"mapObj_removeMetaData", _wrap_mapObj_removeMetaData, METH_VARARGS, NULL},
48864 : { (char *)"mapObj_getFirstMetaDataKey", _wrap_mapObj_getFirstMetaDataKey, METH_VARARGS, NULL},
48865 : { (char *)"mapObj_getNextMetaDataKey", _wrap_mapObj_getNextMetaDataKey, METH_VARARGS, NULL},
48866 : { (char *)"mapObj_setSymbolSet", _wrap_mapObj_setSymbolSet, METH_VARARGS, NULL},
48867 : { (char *)"mapObj_getNumSymbols", _wrap_mapObj_getNumSymbols, METH_VARARGS, NULL},
48868 : { (char *)"mapObj_setFontSet", _wrap_mapObj_setFontSet, METH_VARARGS, NULL},
48869 : { (char *)"mapObj_saveMapContext", _wrap_mapObj_saveMapContext, METH_VARARGS, NULL},
48870 : { (char *)"mapObj_loadMapContext", _wrap_mapObj_loadMapContext, METH_VARARGS, NULL},
48871 : { (char *)"mapObj_moveLayerUp", _wrap_mapObj_moveLayerUp, METH_VARARGS, NULL},
48872 : { (char *)"mapObj_moveLayerDown", _wrap_mapObj_moveLayerDown, METH_VARARGS, NULL},
48873 : { (char *)"mapObj_getLayersDrawingOrder", _wrap_mapObj_getLayersDrawingOrder, METH_VARARGS, NULL},
48874 : { (char *)"mapObj_setLayersDrawingOrder", _wrap_mapObj_setLayersDrawingOrder, METH_VARARGS, NULL},
48875 : { (char *)"mapObj_setConfigOption", _wrap_mapObj_setConfigOption, METH_VARARGS, NULL},
48876 : { (char *)"mapObj_getConfigOption", _wrap_mapObj_getConfigOption, METH_VARARGS, NULL},
48877 : { (char *)"mapObj_applyConfigOptions", _wrap_mapObj_applyConfigOptions, METH_VARARGS, NULL},
48878 : { (char *)"mapObj_applySLD", _wrap_mapObj_applySLD, METH_VARARGS, NULL},
48879 : { (char *)"mapObj_applySLDURL", _wrap_mapObj_applySLDURL, METH_VARARGS, NULL},
48880 : { (char *)"mapObj_generateSLD", _wrap_mapObj_generateSLD, METH_VARARGS, NULL},
48881 : { (char *)"mapObj_processTemplate", _wrap_mapObj_processTemplate, METH_VARARGS, NULL},
48882 : { (char *)"mapObj_processLegendTemplate", _wrap_mapObj_processLegendTemplate, METH_VARARGS, NULL},
48883 : { (char *)"mapObj_processQueryTemplate", _wrap_mapObj_processQueryTemplate, METH_VARARGS, NULL},
48884 : { (char *)"mapObj_getOutputFormatByName", _wrap_mapObj_getOutputFormatByName, METH_VARARGS, NULL},
48885 : { (char *)"mapObj_appendOutputFormat", _wrap_mapObj_appendOutputFormat, METH_VARARGS, NULL},
48886 : { (char *)"mapObj_removeOutputFormat", _wrap_mapObj_removeOutputFormat, METH_VARARGS, NULL},
48887 : { (char *)"mapObj_loadOWSParameters", _wrap_mapObj_loadOWSParameters, METH_VARARGS, NULL},
48888 : { (char *)"mapObj_OWSDispatch", _wrap_mapObj_OWSDispatch, METH_VARARGS, NULL},
48889 : { (char *)"mapObj_convertToString", _wrap_mapObj_convertToString, METH_VARARGS, NULL},
48890 : { (char *)"mapObj_applyDefaultSubstitutions", _wrap_mapObj_applyDefaultSubstitutions, METH_VARARGS, NULL},
48891 : { (char *)"mapObj_applySubstitutions", _wrap_mapObj_applySubstitutions, METH_VARARGS, NULL},
48892 : { (char *)"mapObj_zoomPoint", _wrap_mapObj_zoomPoint, METH_VARARGS, NULL},
48893 : { (char *)"mapObj_zoomRectangle", _wrap_mapObj_zoomRectangle, METH_VARARGS, NULL},
48894 : { (char *)"mapObj_zoomScale", _wrap_mapObj_zoomScale, METH_VARARGS, NULL},
48895 : { (char *)"mapObj_getLayerOrder", _wrap_mapObj_getLayerOrder, METH_VARARGS, NULL},
48896 : { (char *)"mapObj_setLayerOrder", _wrap_mapObj_setLayerOrder, METH_VARARGS, NULL},
48897 : { (char *)"mapObj_getSize", _wrap_mapObj_getSize, METH_VARARGS, NULL},
48898 : { (char *)"mapObj_swigregister", mapObj_swigregister, METH_VARARGS, NULL},
48899 : { (char *)"msSaveImage", _wrap_msSaveImage, METH_VARARGS, NULL},
48900 : { (char *)"msFreeImage", _wrap_msFreeImage, METH_VARARGS, NULL},
48901 : { (char *)"msSetup", _wrap_msSetup, METH_VARARGS, NULL},
48902 : { (char *)"msCleanup", _wrap_msCleanup, METH_VARARGS, NULL},
48903 : { (char *)"msLoadMapFromString", _wrap_msLoadMapFromString, METH_VARARGS, NULL},
48904 : { (char *)"rectObj_minx_set", _wrap_rectObj_minx_set, METH_VARARGS, NULL},
48905 : { (char *)"rectObj_minx_get", _wrap_rectObj_minx_get, METH_VARARGS, NULL},
48906 : { (char *)"rectObj_miny_set", _wrap_rectObj_miny_set, METH_VARARGS, NULL},
48907 : { (char *)"rectObj_miny_get", _wrap_rectObj_miny_get, METH_VARARGS, NULL},
48908 : { (char *)"rectObj_maxx_set", _wrap_rectObj_maxx_set, METH_VARARGS, NULL},
48909 : { (char *)"rectObj_maxx_get", _wrap_rectObj_maxx_get, METH_VARARGS, NULL},
48910 : { (char *)"rectObj_maxy_set", _wrap_rectObj_maxy_set, METH_VARARGS, NULL},
48911 : { (char *)"rectObj_maxy_get", _wrap_rectObj_maxy_get, METH_VARARGS, NULL},
48912 : { (char *)"new_rectObj", _wrap_new_rectObj, METH_VARARGS, NULL},
48913 : { (char *)"delete_rectObj", _wrap_delete_rectObj, METH_VARARGS, NULL},
48914 : { (char *)"rectObj_project", _wrap_rectObj_project, METH_VARARGS, NULL},
48915 : { (char *)"rectObj_fit", _wrap_rectObj_fit, METH_VARARGS, NULL},
48916 : { (char *)"rectObj_draw", _wrap_rectObj_draw, METH_VARARGS, NULL},
48917 : { (char *)"rectObj_getCenter", _wrap_rectObj_getCenter, METH_VARARGS, NULL},
48918 : { (char *)"rectObj_toPolygon", _wrap_rectObj_toPolygon, METH_VARARGS, NULL},
48919 : { (char *)"rectObj_toString", _wrap_rectObj_toString, METH_VARARGS, NULL},
48920 : { (char *)"rectObj_swigregister", rectObj_swigregister, METH_VARARGS, NULL},
48921 : { (char *)"pointObj_x_set", _wrap_pointObj_x_set, METH_VARARGS, NULL},
48922 : { (char *)"pointObj_x_get", _wrap_pointObj_x_get, METH_VARARGS, NULL},
48923 : { (char *)"pointObj_y_set", _wrap_pointObj_y_set, METH_VARARGS, NULL},
48924 : { (char *)"pointObj_y_get", _wrap_pointObj_y_get, METH_VARARGS, NULL},
48925 : { (char *)"new_pointObj", _wrap_new_pointObj, METH_VARARGS, NULL},
48926 : { (char *)"delete_pointObj", _wrap_delete_pointObj, METH_VARARGS, NULL},
48927 : { (char *)"pointObj_project", _wrap_pointObj_project, METH_VARARGS, NULL},
48928 : { (char *)"pointObj_draw", _wrap_pointObj_draw, METH_VARARGS, NULL},
48929 : { (char *)"pointObj_distanceToPoint", _wrap_pointObj_distanceToPoint, METH_VARARGS, NULL},
48930 : { (char *)"pointObj_distanceToSegment", _wrap_pointObj_distanceToSegment, METH_VARARGS, NULL},
48931 : { (char *)"pointObj_distanceToShape", _wrap_pointObj_distanceToShape, METH_VARARGS, NULL},
48932 : { (char *)"pointObj_setXY", _wrap_pointObj_setXY, METH_VARARGS, NULL},
48933 : { (char *)"pointObj_setXYZ", _wrap_pointObj_setXYZ, METH_VARARGS, NULL},
48934 : { (char *)"pointObj_setXYZM", _wrap_pointObj_setXYZM, METH_VARARGS, NULL},
48935 : { (char *)"pointObj_toString", _wrap_pointObj_toString, METH_VARARGS, NULL},
48936 : { (char *)"pointObj_toShape", _wrap_pointObj_toShape, METH_VARARGS, NULL},
48937 : { (char *)"pointObj_swigregister", pointObj_swigregister, METH_VARARGS, NULL},
48938 : { (char *)"lineObj_numpoints_get", _wrap_lineObj_numpoints_get, METH_VARARGS, NULL},
48939 : { (char *)"new_lineObj", _wrap_new_lineObj, METH_VARARGS, NULL},
48940 : { (char *)"delete_lineObj", _wrap_delete_lineObj, METH_VARARGS, NULL},
48941 : { (char *)"lineObj_project", _wrap_lineObj_project, METH_VARARGS, NULL},
48942 : { (char *)"lineObj_get", _wrap_lineObj_get, METH_VARARGS, NULL},
48943 : { (char *)"lineObj_add", _wrap_lineObj_add, METH_VARARGS, NULL},
48944 : { (char *)"lineObj_set", _wrap_lineObj_set, METH_VARARGS, NULL},
48945 : { (char *)"lineObj_swigregister", lineObj_swigregister, METH_VARARGS, NULL},
48946 : { (char *)"shapeObj_numlines_get", _wrap_shapeObj_numlines_get, METH_VARARGS, NULL},
48947 : { (char *)"shapeObj_numvalues_get", _wrap_shapeObj_numvalues_get, METH_VARARGS, NULL},
48948 : { (char *)"shapeObj_bounds_set", _wrap_shapeObj_bounds_set, METH_VARARGS, NULL},
48949 : { (char *)"shapeObj_bounds_get", _wrap_shapeObj_bounds_get, METH_VARARGS, NULL},
48950 : { (char *)"shapeObj_type_set", _wrap_shapeObj_type_set, METH_VARARGS, NULL},
48951 : { (char *)"shapeObj_type_get", _wrap_shapeObj_type_get, METH_VARARGS, NULL},
48952 : { (char *)"shapeObj_index_set", _wrap_shapeObj_index_set, METH_VARARGS, NULL},
48953 : { (char *)"shapeObj_index_get", _wrap_shapeObj_index_get, METH_VARARGS, NULL},
48954 : { (char *)"shapeObj_tileindex_set", _wrap_shapeObj_tileindex_set, METH_VARARGS, NULL},
48955 : { (char *)"shapeObj_tileindex_get", _wrap_shapeObj_tileindex_get, METH_VARARGS, NULL},
48956 : { (char *)"shapeObj_classindex_set", _wrap_shapeObj_classindex_set, METH_VARARGS, NULL},
48957 : { (char *)"shapeObj_classindex_get", _wrap_shapeObj_classindex_get, METH_VARARGS, NULL},
48958 : { (char *)"shapeObj_text_set", _wrap_shapeObj_text_set, METH_VARARGS, NULL},
48959 : { (char *)"shapeObj_text_get", _wrap_shapeObj_text_get, METH_VARARGS, NULL},
48960 : { (char *)"shapeObj_scratch_set", _wrap_shapeObj_scratch_set, METH_VARARGS, NULL},
48961 : { (char *)"shapeObj_scratch_get", _wrap_shapeObj_scratch_get, METH_VARARGS, NULL},
48962 : { (char *)"shapeObj_resultindex_set", _wrap_shapeObj_resultindex_set, METH_VARARGS, NULL},
48963 : { (char *)"shapeObj_resultindex_get", _wrap_shapeObj_resultindex_get, METH_VARARGS, NULL},
48964 : { (char *)"new_shapeObj", _wrap_new_shapeObj, METH_VARARGS, NULL},
48965 : { (char *)"delete_shapeObj", _wrap_delete_shapeObj, METH_VARARGS, NULL},
48966 : { (char *)"shapeObj_fromWKT", _wrap_shapeObj_fromWKT, METH_VARARGS, NULL},
48967 : { (char *)"shapeObj_project", _wrap_shapeObj_project, METH_VARARGS, NULL},
48968 : { (char *)"shapeObj_get", _wrap_shapeObj_get, METH_VARARGS, NULL},
48969 : { (char *)"shapeObj_add", _wrap_shapeObj_add, METH_VARARGS, NULL},
48970 : { (char *)"shapeObj_draw", _wrap_shapeObj_draw, METH_VARARGS, NULL},
48971 : { (char *)"shapeObj_setBounds", _wrap_shapeObj_setBounds, METH_VARARGS, NULL},
48972 : { (char *)"shapeObj_clone", _wrap_shapeObj_clone, METH_VARARGS, NULL},
48973 : { (char *)"shapeObj_copy", _wrap_shapeObj_copy, METH_VARARGS, NULL},
48974 : { (char *)"shapeObj_toWKT", _wrap_shapeObj_toWKT, METH_VARARGS, NULL},
48975 : { (char *)"shapeObj_buffer", _wrap_shapeObj_buffer, METH_VARARGS, NULL},
48976 : { (char *)"shapeObj_simplify", _wrap_shapeObj_simplify, METH_VARARGS, NULL},
48977 : { (char *)"shapeObj_topologyPreservingSimplify", _wrap_shapeObj_topologyPreservingSimplify, METH_VARARGS, NULL},
48978 : { (char *)"shapeObj_convexHull", _wrap_shapeObj_convexHull, METH_VARARGS, NULL},
48979 : { (char *)"shapeObj_boundary", _wrap_shapeObj_boundary, METH_VARARGS, NULL},
48980 : { (char *)"shapeObj_getCentroid", _wrap_shapeObj_getCentroid, METH_VARARGS, NULL},
48981 : { (char *)"shapeObj_Union", _wrap_shapeObj_Union, METH_VARARGS, NULL},
48982 : { (char *)"shapeObj_intersection", _wrap_shapeObj_intersection, METH_VARARGS, NULL},
48983 : { (char *)"shapeObj_difference", _wrap_shapeObj_difference, METH_VARARGS, NULL},
48984 : { (char *)"shapeObj_symDifference", _wrap_shapeObj_symDifference, METH_VARARGS, NULL},
48985 : { (char *)"shapeObj_overlaps", _wrap_shapeObj_overlaps, METH_VARARGS, NULL},
48986 : { (char *)"shapeObj_within", _wrap_shapeObj_within, METH_VARARGS, NULL},
48987 : { (char *)"shapeObj_crosses", _wrap_shapeObj_crosses, METH_VARARGS, NULL},
48988 : { (char *)"shapeObj_intersects", _wrap_shapeObj_intersects, METH_VARARGS, NULL},
48989 : { (char *)"shapeObj_touches", _wrap_shapeObj_touches, METH_VARARGS, NULL},
48990 : { (char *)"shapeObj_equals", _wrap_shapeObj_equals, METH_VARARGS, NULL},
48991 : { (char *)"shapeObj_disjoint", _wrap_shapeObj_disjoint, METH_VARARGS, NULL},
48992 : { (char *)"shapeObj_getArea", _wrap_shapeObj_getArea, METH_VARARGS, NULL},
48993 : { (char *)"shapeObj_getLength", _wrap_shapeObj_getLength, METH_VARARGS, NULL},
48994 : { (char *)"shapeObj_getValue", _wrap_shapeObj_getValue, METH_VARARGS, NULL},
48995 : { (char *)"shapeObj_contains", _wrap_shapeObj_contains, METH_VARARGS, NULL},
48996 : { (char *)"shapeObj_distanceToPoint", _wrap_shapeObj_distanceToPoint, METH_VARARGS, NULL},
48997 : { (char *)"shapeObj_distanceToShape", _wrap_shapeObj_distanceToShape, METH_VARARGS, NULL},
48998 : { (char *)"shapeObj_getLabelPoint", _wrap_shapeObj_getLabelPoint, METH_VARARGS, NULL},
48999 : { (char *)"shapeObj_setValue", _wrap_shapeObj_setValue, METH_VARARGS, NULL},
49000 : { (char *)"shapeObj_initValues", _wrap_shapeObj_initValues, METH_VARARGS, NULL},
49001 : { (char *)"shapeObj_swigregister", shapeObj_swigregister, METH_VARARGS, NULL},
49002 : { (char *)"errorObj_code_set", _wrap_errorObj_code_set, METH_VARARGS, NULL},
49003 : { (char *)"errorObj_code_get", _wrap_errorObj_code_get, METH_VARARGS, NULL},
49004 : { (char *)"errorObj_routine_set", _wrap_errorObj_routine_set, METH_VARARGS, NULL},
49005 : { (char *)"errorObj_routine_get", _wrap_errorObj_routine_get, METH_VARARGS, NULL},
49006 : { (char *)"errorObj_message_set", _wrap_errorObj_message_set, METH_VARARGS, NULL},
49007 : { (char *)"errorObj_message_get", _wrap_errorObj_message_get, METH_VARARGS, NULL},
49008 : { (char *)"errorObj_isreported_set", _wrap_errorObj_isreported_set, METH_VARARGS, NULL},
49009 : { (char *)"errorObj_isreported_get", _wrap_errorObj_isreported_get, METH_VARARGS, NULL},
49010 : { (char *)"errorObj_errorcount_set", _wrap_errorObj_errorcount_set, METH_VARARGS, NULL},
49011 : { (char *)"errorObj_errorcount_get", _wrap_errorObj_errorcount_get, METH_VARARGS, NULL},
49012 : { (char *)"new_errorObj", _wrap_new_errorObj, METH_VARARGS, NULL},
49013 : { (char *)"delete_errorObj", _wrap_delete_errorObj, METH_VARARGS, NULL},
49014 : { (char *)"errorObj_next", _wrap_errorObj_next, METH_VARARGS, NULL},
49015 : { (char *)"errorObj_swigregister", errorObj_swigregister, METH_VARARGS, NULL},
49016 : { (char *)"msGetErrorObj", _wrap_msGetErrorObj, METH_VARARGS, NULL},
49017 : { (char *)"msResetErrorList", _wrap_msResetErrorList, METH_VARARGS, NULL},
49018 : { (char *)"msGetVersion", _wrap_msGetVersion, METH_VARARGS, NULL},
49019 : { (char *)"msGetVersionInt", _wrap_msGetVersionInt, METH_VARARGS, NULL},
49020 : { (char *)"msGetErrorString", _wrap_msGetErrorString, METH_VARARGS, NULL},
49021 : { (char *)"DBFInfo_nRecords_get", _wrap_DBFInfo_nRecords_get, METH_VARARGS, NULL},
49022 : { (char *)"DBFInfo_nFields_get", _wrap_DBFInfo_nFields_get, METH_VARARGS, NULL},
49023 : { (char *)"DBFInfo_getFieldName", _wrap_DBFInfo_getFieldName, METH_VARARGS, NULL},
49024 : { (char *)"DBFInfo_getFieldWidth", _wrap_DBFInfo_getFieldWidth, METH_VARARGS, NULL},
49025 : { (char *)"DBFInfo_getFieldDecimals", _wrap_DBFInfo_getFieldDecimals, METH_VARARGS, NULL},
49026 : { (char *)"DBFInfo_getFieldType", _wrap_DBFInfo_getFieldType, METH_VARARGS, NULL},
49027 : { (char *)"new_DBFInfo", _wrap_new_DBFInfo, METH_VARARGS, NULL},
49028 : { (char *)"delete_DBFInfo", _wrap_delete_DBFInfo, METH_VARARGS, NULL},
49029 : { (char *)"DBFInfo_swigregister", DBFInfo_swigregister, METH_VARARGS, NULL},
49030 : { (char *)"shapefileObj_type_get", _wrap_shapefileObj_type_get, METH_VARARGS, NULL},
49031 : { (char *)"shapefileObj_numshapes_get", _wrap_shapefileObj_numshapes_get, METH_VARARGS, NULL},
49032 : { (char *)"shapefileObj_bounds_get", _wrap_shapefileObj_bounds_get, METH_VARARGS, NULL},
49033 : { (char *)"new_shapefileObj", _wrap_new_shapefileObj, METH_VARARGS, NULL},
49034 : { (char *)"delete_shapefileObj", _wrap_delete_shapefileObj, METH_VARARGS, NULL},
49035 : { (char *)"shapefileObj_get", _wrap_shapefileObj_get, METH_VARARGS, NULL},
49036 : { (char *)"shapefileObj_getShape", _wrap_shapefileObj_getShape, METH_VARARGS, NULL},
49037 : { (char *)"shapefileObj_getPoint", _wrap_shapefileObj_getPoint, METH_VARARGS, NULL},
49038 : { (char *)"shapefileObj_getTransformed", _wrap_shapefileObj_getTransformed, METH_VARARGS, NULL},
49039 : { (char *)"shapefileObj_getExtent", _wrap_shapefileObj_getExtent, METH_VARARGS, NULL},
49040 : { (char *)"shapefileObj_add", _wrap_shapefileObj_add, METH_VARARGS, NULL},
49041 : { (char *)"shapefileObj_addPoint", _wrap_shapefileObj_addPoint, METH_VARARGS, NULL},
49042 : { (char *)"shapefileObj_getDBF", _wrap_shapefileObj_getDBF, METH_VARARGS, NULL},
49043 : { (char *)"shapefileObj_swigregister", shapefileObj_swigregister, METH_VARARGS, NULL},
49044 : { (char *)"projectionObj_numargs_get", _wrap_projectionObj_numargs_get, METH_VARARGS, NULL},
49045 : { (char *)"projectionObj_automatic_get", _wrap_projectionObj_automatic_get, METH_VARARGS, NULL},
49046 : { (char *)"projectionObj_wellknownprojection_set", _wrap_projectionObj_wellknownprojection_set, METH_VARARGS, NULL},
49047 : { (char *)"projectionObj_wellknownprojection_get", _wrap_projectionObj_wellknownprojection_get, METH_VARARGS, NULL},
49048 : { (char *)"new_projectionObj", _wrap_new_projectionObj, METH_VARARGS, NULL},
49049 : { (char *)"delete_projectionObj", _wrap_delete_projectionObj, METH_VARARGS, NULL},
49050 : { (char *)"projectionObj_setWKTProjection", _wrap_projectionObj_setWKTProjection, METH_VARARGS, NULL},
49051 : { (char *)"projectionObj_getUnits", _wrap_projectionObj_getUnits, METH_VARARGS, NULL},
49052 : { (char *)"projectionObj_swigregister", projectionObj_swigregister, METH_VARARGS, NULL},
49053 : { (char *)"colorObj_red_set", _wrap_colorObj_red_set, METH_VARARGS, (char *)"Red component of color in range [0-255]"},
49054 : { (char *)"colorObj_red_get", _wrap_colorObj_red_get, METH_VARARGS, (char *)"Red component of color in range [0-255]"},
49055 : { (char *)"colorObj_green_set", _wrap_colorObj_green_set, METH_VARARGS, (char *)"Green component of color in range [0-255]"},
49056 : { (char *)"colorObj_green_get", _wrap_colorObj_green_get, METH_VARARGS, (char *)"Green component of color in range [0-255]"},
49057 : { (char *)"colorObj_blue_set", _wrap_colorObj_blue_set, METH_VARARGS, (char *)"Blue component of color in range [0-255]"},
49058 : { (char *)"colorObj_blue_get", _wrap_colorObj_blue_get, METH_VARARGS, (char *)"Blue component of color in range [0-255]"},
49059 : { (char *)"colorObj_alpha_set", _wrap_colorObj_alpha_set, METH_VARARGS, (char *)"Alpha (opacity) component of color in range [0-255]"},
49060 : { (char *)"colorObj_alpha_get", _wrap_colorObj_alpha_get, METH_VARARGS, (char *)"Alpha (opacity) component of color in range [0-255]"},
49061 : { (char *)"new_colorObj", _wrap_new_colorObj, METH_VARARGS, (char *)"An object representing a color."},
49062 : { (char *)"delete_colorObj", _wrap_delete_colorObj, METH_VARARGS, NULL},
49063 : { (char *)"colorObj_setRGB", _wrap_colorObj_setRGB, METH_VARARGS, NULL},
49064 : { (char *)"colorObj_setHex", _wrap_colorObj_setHex, METH_VARARGS, NULL},
49065 : { (char *)"colorObj_toHex", _wrap_colorObj_toHex, METH_VARARGS, NULL},
49066 : { (char *)"colorObj_swigregister", colorObj_swigregister, METH_VARARGS, NULL},
49067 : { (char *)"symbolObj_name_set", _wrap_symbolObj_name_set, METH_VARARGS, NULL},
49068 : { (char *)"symbolObj_name_get", _wrap_symbolObj_name_get, METH_VARARGS, NULL},
49069 : { (char *)"symbolObj_type_set", _wrap_symbolObj_type_set, METH_VARARGS, NULL},
49070 : { (char *)"symbolObj_type_get", _wrap_symbolObj_type_get, METH_VARARGS, NULL},
49071 : { (char *)"symbolObj_inmapfile_set", _wrap_symbolObj_inmapfile_set, METH_VARARGS, NULL},
49072 : { (char *)"symbolObj_inmapfile_get", _wrap_symbolObj_inmapfile_get, METH_VARARGS, NULL},
49073 : { (char *)"symbolObj_sizex_set", _wrap_symbolObj_sizex_set, METH_VARARGS, NULL},
49074 : { (char *)"symbolObj_sizex_get", _wrap_symbolObj_sizex_get, METH_VARARGS, NULL},
49075 : { (char *)"symbolObj_sizey_set", _wrap_symbolObj_sizey_set, METH_VARARGS, NULL},
49076 : { (char *)"symbolObj_sizey_get", _wrap_symbolObj_sizey_get, METH_VARARGS, NULL},
49077 : { (char *)"symbolObj_minx_set", _wrap_symbolObj_minx_set, METH_VARARGS, NULL},
49078 : { (char *)"symbolObj_minx_get", _wrap_symbolObj_minx_get, METH_VARARGS, NULL},
49079 : { (char *)"symbolObj_miny_set", _wrap_symbolObj_miny_set, METH_VARARGS, NULL},
49080 : { (char *)"symbolObj_miny_get", _wrap_symbolObj_miny_get, METH_VARARGS, NULL},
49081 : { (char *)"symbolObj_maxx_set", _wrap_symbolObj_maxx_set, METH_VARARGS, NULL},
49082 : { (char *)"symbolObj_maxx_get", _wrap_symbolObj_maxx_get, METH_VARARGS, NULL},
49083 : { (char *)"symbolObj_maxy_set", _wrap_symbolObj_maxy_set, METH_VARARGS, NULL},
49084 : { (char *)"symbolObj_maxy_get", _wrap_symbolObj_maxy_get, METH_VARARGS, NULL},
49085 : { (char *)"symbolObj_refcount_get", _wrap_symbolObj_refcount_get, METH_VARARGS, NULL},
49086 : { (char *)"symbolObj_numpoints_get", _wrap_symbolObj_numpoints_get, METH_VARARGS, NULL},
49087 : { (char *)"symbolObj_filled_set", _wrap_symbolObj_filled_set, METH_VARARGS, NULL},
49088 : { (char *)"symbolObj_filled_get", _wrap_symbolObj_filled_get, METH_VARARGS, NULL},
49089 : { (char *)"symbolObj_anchorpoint_x_set", _wrap_symbolObj_anchorpoint_x_set, METH_VARARGS, NULL},
49090 : { (char *)"symbolObj_anchorpoint_x_get", _wrap_symbolObj_anchorpoint_x_get, METH_VARARGS, NULL},
49091 : { (char *)"symbolObj_anchorpoint_y_set", _wrap_symbolObj_anchorpoint_y_set, METH_VARARGS, NULL},
49092 : { (char *)"symbolObj_anchorpoint_y_get", _wrap_symbolObj_anchorpoint_y_get, METH_VARARGS, NULL},
49093 : { (char *)"symbolObj_imagepath_get", _wrap_symbolObj_imagepath_get, METH_VARARGS, NULL},
49094 : { (char *)"symbolObj_transparent_set", _wrap_symbolObj_transparent_set, METH_VARARGS, NULL},
49095 : { (char *)"symbolObj_transparent_get", _wrap_symbolObj_transparent_get, METH_VARARGS, NULL},
49096 : { (char *)"symbolObj_transparentcolor_set", _wrap_symbolObj_transparentcolor_set, METH_VARARGS, NULL},
49097 : { (char *)"symbolObj_transparentcolor_get", _wrap_symbolObj_transparentcolor_get, METH_VARARGS, NULL},
49098 : { (char *)"symbolObj_character_set", _wrap_symbolObj_character_set, METH_VARARGS, NULL},
49099 : { (char *)"symbolObj_character_get", _wrap_symbolObj_character_get, METH_VARARGS, NULL},
49100 : { (char *)"symbolObj_font_set", _wrap_symbolObj_font_set, METH_VARARGS, NULL},
49101 : { (char *)"symbolObj_font_get", _wrap_symbolObj_font_get, METH_VARARGS, NULL},
49102 : { (char *)"new_symbolObj", _wrap_new_symbolObj, METH_VARARGS, NULL},
49103 : { (char *)"delete_symbolObj", _wrap_delete_symbolObj, METH_VARARGS, NULL},
49104 : { (char *)"symbolObj_setImagepath", _wrap_symbolObj_setImagepath, METH_VARARGS, NULL},
49105 : { (char *)"symbolObj_setPoints", _wrap_symbolObj_setPoints, METH_VARARGS, NULL},
49106 : { (char *)"symbolObj_getPoints", _wrap_symbolObj_getPoints, METH_VARARGS, NULL},
49107 : { (char *)"symbolObj_getImage", _wrap_symbolObj_getImage, METH_VARARGS, NULL},
49108 : { (char *)"symbolObj_setImage", _wrap_symbolObj_setImage, METH_VARARGS, NULL},
49109 : { (char *)"symbolObj_swigregister", symbolObj_swigregister, METH_VARARGS, NULL},
49110 : { (char *)"hashTableObj_numitems_get", _wrap_hashTableObj_numitems_get, METH_VARARGS, NULL},
49111 : { (char *)"new_hashTableObj", _wrap_new_hashTableObj, METH_VARARGS, NULL},
49112 : { (char *)"delete_hashTableObj", _wrap_delete_hashTableObj, METH_VARARGS, NULL},
49113 : { (char *)"hashTableObj_set", _wrap_hashTableObj_set, METH_VARARGS, NULL},
49114 : { (char *)"hashTableObj_get", _wrap_hashTableObj_get, METH_VARARGS, NULL},
49115 : { (char *)"hashTableObj_remove", _wrap_hashTableObj_remove, METH_VARARGS, NULL},
49116 : { (char *)"hashTableObj_clear", _wrap_hashTableObj_clear, METH_VARARGS, NULL},
49117 : { (char *)"hashTableObj_nextKey", _wrap_hashTableObj_nextKey, METH_VARARGS, NULL},
49118 : { (char *)"hashTableObj_swigregister", hashTableObj_swigregister, METH_VARARGS, NULL},
49119 : { (char *)"OWSRequest_NumParams_get", _wrap_OWSRequest_NumParams_get, METH_VARARGS, NULL},
49120 : { (char *)"OWSRequest_type_set", _wrap_OWSRequest_type_set, METH_VARARGS, NULL},
49121 : { (char *)"OWSRequest_type_get", _wrap_OWSRequest_type_get, METH_VARARGS, NULL},
49122 : { (char *)"OWSRequest_contenttype_set", _wrap_OWSRequest_contenttype_set, METH_VARARGS, NULL},
49123 : { (char *)"OWSRequest_contenttype_get", _wrap_OWSRequest_contenttype_get, METH_VARARGS, NULL},
49124 : { (char *)"OWSRequest_postrequest_set", _wrap_OWSRequest_postrequest_set, METH_VARARGS, NULL},
49125 : { (char *)"OWSRequest_postrequest_get", _wrap_OWSRequest_postrequest_get, METH_VARARGS, NULL},
49126 : { (char *)"OWSRequest_httpcookiedata_set", _wrap_OWSRequest_httpcookiedata_set, METH_VARARGS, NULL},
49127 : { (char *)"OWSRequest_httpcookiedata_get", _wrap_OWSRequest_httpcookiedata_get, METH_VARARGS, NULL},
49128 : { (char *)"new_OWSRequest", _wrap_new_OWSRequest, METH_VARARGS, NULL},
49129 : { (char *)"delete_OWSRequest", _wrap_delete_OWSRequest, METH_VARARGS, NULL},
49130 : { (char *)"OWSRequest_loadParams", _wrap_OWSRequest_loadParams, METH_VARARGS, NULL},
49131 : { (char *)"OWSRequest_loadParamsFromURL", _wrap_OWSRequest_loadParamsFromURL, METH_VARARGS, NULL},
49132 : { (char *)"OWSRequest_setParameter", _wrap_OWSRequest_setParameter, METH_VARARGS, NULL},
49133 : { (char *)"OWSRequest_addParameter", _wrap_OWSRequest_addParameter, METH_VARARGS, NULL},
49134 : { (char *)"OWSRequest_getName", _wrap_OWSRequest_getName, METH_VARARGS, NULL},
49135 : { (char *)"OWSRequest_getValue", _wrap_OWSRequest_getValue, METH_VARARGS, NULL},
49136 : { (char *)"OWSRequest_getValueByName", _wrap_OWSRequest_getValueByName, METH_VARARGS, NULL},
49137 : { (char *)"OWSRequest_swigregister", OWSRequest_swigregister, METH_VARARGS, NULL},
49138 : { (char *)"msConnPoolCloseUnreferenced", _wrap_msConnPoolCloseUnreferenced, METH_VARARGS, NULL},
49139 : { (char *)"msIO_resetHandlers", _wrap_msIO_resetHandlers, METH_VARARGS, NULL},
49140 : { (char *)"msIO_installStdoutToBuffer", _wrap_msIO_installStdoutToBuffer, METH_VARARGS, NULL},
49141 : { (char *)"msIO_installStdinFromBuffer", _wrap_msIO_installStdinFromBuffer, METH_VARARGS, NULL},
49142 : { (char *)"msIO_stripStdoutBufferContentType", _wrap_msIO_stripStdoutBufferContentType, METH_VARARGS, NULL},
49143 : { (char *)"msIO_stripStdoutBufferContentHeaders", _wrap_msIO_stripStdoutBufferContentHeaders, METH_VARARGS, NULL},
49144 : { (char *)"msIO_getStdoutBufferString", _wrap_msIO_getStdoutBufferString, METH_VARARGS, NULL},
49145 : { (char *)"msIO_getStdoutBufferBytes", _wrap_msIO_getStdoutBufferBytes, METH_VARARGS, NULL},
49146 : { (char *)"msIO_getAndStripStdoutBufferMimeHeaders", _wrap_msIO_getAndStripStdoutBufferMimeHeaders, METH_VARARGS, NULL},
49147 : { NULL, NULL, 0, NULL }
49148 : };
49149 :
49150 :
49151 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
49152 :
49153 0 : static void *_p_intarrayTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
49154 0 : return (void *)((int *) ((intarray *) x));
49155 : }
49156 : static swig_type_info _swigt__p_CompositingOperation = {"_p_CompositingOperation", "enum CompositingOperation *|CompositingOperation *", 0, 0, (void*)0, 0};
49157 : static swig_type_info _swigt__p_DBFFieldType = {"_p_DBFFieldType", "enum DBFFieldType *|DBFFieldType *", 0, 0, (void*)0, 0};
49158 : static swig_type_info _swigt__p_DBFInfo = {"_p_DBFInfo", "DBFInfo *", 0, 0, (void*)0, 0};
49159 : static swig_type_info _swigt__p__CompositingFilter = {"_p__CompositingFilter", "struct _CompositingFilter *|_CompositingFilter *|CompositingFilter *", 0, 0, (void*)0, 0};
49160 : static swig_type_info _swigt__p__LayerCompositer = {"_p__LayerCompositer", "struct _LayerCompositer *|_LayerCompositer *|LayerCompositer *", 0, 0, (void*)0, 0};
49161 : static swig_type_info _swigt__p_cgiRequestObj = {"_p_cgiRequestObj", "cgiRequestObj *", 0, 0, (void*)0, 0};
49162 : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
49163 : static swig_type_info _swigt__p_classObj = {"_p_classObj", "classObj *|struct classObj *", 0, 0, (void*)0, 0};
49164 : static swig_type_info _swigt__p_clusterObj = {"_p_clusterObj", "clusterObj *", 0, 0, (void*)0, 0};
49165 : static swig_type_info _swigt__p_colorObj = {"_p_colorObj", "colorObj *", 0, 0, (void*)0, 0};
49166 : static swig_type_info _swigt__p_debugLevel = {"_p_debugLevel", "enum debugLevel *|debugLevel *", 0, 0, (void*)0, 0};
49167 : static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0};
49168 : static swig_type_info _swigt__p_errorObj = {"_p_errorObj", "struct errorObj *|errorObj *", 0, 0, (void*)0, 0};
49169 : static swig_type_info _swigt__p_expressionObj = {"_p_expressionObj", "expressionObj *", 0, 0, (void*)0, 0};
49170 : static swig_type_info _swigt__p_fontSetObj = {"_p_fontSetObj", "fontSetObj *", 0, 0, (void*)0, 0};
49171 : static swig_type_info _swigt__p_hashTableObj = {"_p_hashTableObj", "hashTableObj *", 0, 0, (void*)0, 0};
49172 : static swig_type_info _swigt__p_imageObj = {"_p_imageObj", "imageObj *|struct imageObj *", 0, 0, (void*)0, 0};
49173 : static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
49174 : static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *|ms_int32 *", 0, 0, (void*)0, 0};
49175 : static swig_type_info _swigt__p_intarray = {"_p_intarray", "intarray *", 0, 0, (void*)0, 0};
49176 : static swig_type_info _swigt__p_labelCacheMemberObj = {"_p_labelCacheMemberObj", "labelCacheMemberObj *", 0, 0, (void*)0, 0};
49177 : static swig_type_info _swigt__p_labelCacheObj = {"_p_labelCacheObj", "labelCacheObj *", 0, 0, (void*)0, 0};
49178 : static swig_type_info _swigt__p_labelCacheSlotObj = {"_p_labelCacheSlotObj", "labelCacheSlotObj *", 0, 0, (void*)0, 0};
49179 : static swig_type_info _swigt__p_labelLeaderObj = {"_p_labelLeaderObj", "labelLeaderObj *", 0, 0, (void*)0, 0};
49180 : static swig_type_info _swigt__p_labelObj = {"_p_labelObj", "struct labelObj *|labelObj *", 0, 0, (void*)0, 0};
49181 : static swig_type_info _swigt__p_layerObj = {"_p_layerObj", "struct layerObj *|layerObj *", 0, 0, (void*)0, 0};
49182 : static swig_type_info _swigt__p_legendObj = {"_p_legendObj", "legendObj *", 0, 0, (void*)0, 0};
49183 : static swig_type_info _swigt__p_lineObj = {"_p_lineObj", "lineObj *|multipointObj *", 0, 0, (void*)0, 0};
49184 : static swig_type_info _swigt__p_mapObj = {"_p_mapObj", "struct mapObj *|mapObj *", 0, 0, (void*)0, 0};
49185 : static swig_type_info _swigt__p_markerCacheMemberObj = {"_p_markerCacheMemberObj", "markerCacheMemberObj *", 0, 0, (void*)0, 0};
49186 : static swig_type_info _swigt__p_outputFormatObj = {"_p_outputFormatObj", "outputFormatObj *", 0, 0, (void*)0, 0};
49187 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
49188 : static swig_type_info _swigt__p_p_double = {"_p_p_double", "double **", 0, 0, (void*)0, 0};
49189 : static swig_type_info _swigt__p_p_labelCacheMemberObj = {"_p_p_labelCacheMemberObj", "labelCacheMemberObj **", 0, 0, (void*)0, 0};
49190 : static swig_type_info _swigt__p_p_textSymbolObj = {"_p_p_textSymbolObj", "textSymbolObj **", 0, 0, (void*)0, 0};
49191 : static swig_type_info _swigt__p_pointObj = {"_p_pointObj", "pointObj *", 0, 0, (void*)0, 0};
49192 : static swig_type_info _swigt__p_projectionContext = {"_p_projectionContext", "struct projectionContext *|projectionContext *", 0, 0, (void*)0, 0};
49193 : static swig_type_info _swigt__p_projectionObj = {"_p_projectionObj", "projectionObj *", 0, 0, (void*)0, 0};
49194 : static swig_type_info _swigt__p_queryMapObj = {"_p_queryMapObj", "queryMapObj *", 0, 0, (void*)0, 0};
49195 : static swig_type_info _swigt__p_rectObj = {"_p_rectObj", "rectObj *", 0, 0, (void*)0, 0};
49196 : static swig_type_info _swigt__p_referenceMapObj = {"_p_referenceMapObj", "referenceMapObj *", 0, 0, (void*)0, 0};
49197 : static swig_type_info _swigt__p_resultCacheObj = {"_p_resultCacheObj", "resultCacheObj *", 0, 0, (void*)0, 0};
49198 : static swig_type_info _swigt__p_resultObj = {"_p_resultObj", "resultObj *", 0, 0, (void*)0, 0};
49199 : static swig_type_info _swigt__p_scaleTokenEntryObj = {"_p_scaleTokenEntryObj", "scaleTokenEntryObj *", 0, 0, (void*)0, 0};
49200 : static swig_type_info _swigt__p_scaleTokenObj = {"_p_scaleTokenObj", "scaleTokenObj *", 0, 0, (void*)0, 0};
49201 : static swig_type_info _swigt__p_scalebarObj = {"_p_scalebarObj", "scalebarObj *", 0, 0, (void*)0, 0};
49202 : static swig_type_info _swigt__p_shapeObj = {"_p_shapeObj", "shapeObj *", 0, 0, (void*)0, 0};
49203 : static swig_type_info _swigt__p_shapefileObj = {"_p_shapefileObj", "shapefileObj *", 0, 0, (void*)0, 0};
49204 : static swig_type_info _swigt__p_styleObj = {"_p_styleObj", "struct styleObj *|styleObj *", 0, 0, (void*)0, 0};
49205 : static swig_type_info _swigt__p_symbolObj = {"_p_symbolObj", "symbolObj *|struct symbolObj *", 0, 0, (void*)0, 0};
49206 : static swig_type_info _swigt__p_symbolSetObj = {"_p_symbolSetObj", "symbolSetObj *", 0, 0, (void*)0, 0};
49207 : static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *|ms_uint32 *", 0, 0, (void*)0, 0};
49208 : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
49209 : static swig_type_info _swigt__p_webObj = {"_p_webObj", "webObj *", 0, 0, (void*)0, 0};
49210 :
49211 : static swig_type_info *swig_type_initial[] = {
49212 : &_swigt__p_CompositingOperation,
49213 : &_swigt__p_DBFFieldType,
49214 : &_swigt__p_DBFInfo,
49215 : &_swigt__p__CompositingFilter,
49216 : &_swigt__p__LayerCompositer,
49217 : &_swigt__p_cgiRequestObj,
49218 : &_swigt__p_char,
49219 : &_swigt__p_classObj,
49220 : &_swigt__p_clusterObj,
49221 : &_swigt__p_colorObj,
49222 : &_swigt__p_debugLevel,
49223 : &_swigt__p_double,
49224 : &_swigt__p_errorObj,
49225 : &_swigt__p_expressionObj,
49226 : &_swigt__p_fontSetObj,
49227 : &_swigt__p_hashTableObj,
49228 : &_swigt__p_imageObj,
49229 : &_swigt__p_int,
49230 : &_swigt__p_int32_t,
49231 : &_swigt__p_intarray,
49232 : &_swigt__p_labelCacheMemberObj,
49233 : &_swigt__p_labelCacheObj,
49234 : &_swigt__p_labelCacheSlotObj,
49235 : &_swigt__p_labelLeaderObj,
49236 : &_swigt__p_labelObj,
49237 : &_swigt__p_layerObj,
49238 : &_swigt__p_legendObj,
49239 : &_swigt__p_lineObj,
49240 : &_swigt__p_mapObj,
49241 : &_swigt__p_markerCacheMemberObj,
49242 : &_swigt__p_outputFormatObj,
49243 : &_swigt__p_p_char,
49244 : &_swigt__p_p_double,
49245 : &_swigt__p_p_labelCacheMemberObj,
49246 : &_swigt__p_p_textSymbolObj,
49247 : &_swigt__p_pointObj,
49248 : &_swigt__p_projectionContext,
49249 : &_swigt__p_projectionObj,
49250 : &_swigt__p_queryMapObj,
49251 : &_swigt__p_rectObj,
49252 : &_swigt__p_referenceMapObj,
49253 : &_swigt__p_resultCacheObj,
49254 : &_swigt__p_resultObj,
49255 : &_swigt__p_scaleTokenEntryObj,
49256 : &_swigt__p_scaleTokenObj,
49257 : &_swigt__p_scalebarObj,
49258 : &_swigt__p_shapeObj,
49259 : &_swigt__p_shapefileObj,
49260 : &_swigt__p_styleObj,
49261 : &_swigt__p_symbolObj,
49262 : &_swigt__p_symbolSetObj,
49263 : &_swigt__p_uint32_t,
49264 : &_swigt__p_void,
49265 : &_swigt__p_webObj,
49266 : };
49267 :
49268 : static swig_cast_info _swigc__p_CompositingOperation[] = { {&_swigt__p_CompositingOperation, 0, 0, 0},{0, 0, 0, 0}};
49269 : static swig_cast_info _swigc__p_DBFFieldType[] = { {&_swigt__p_DBFFieldType, 0, 0, 0},{0, 0, 0, 0}};
49270 : static swig_cast_info _swigc__p_DBFInfo[] = { {&_swigt__p_DBFInfo, 0, 0, 0},{0, 0, 0, 0}};
49271 : static swig_cast_info _swigc__p__CompositingFilter[] = { {&_swigt__p__CompositingFilter, 0, 0, 0},{0, 0, 0, 0}};
49272 : static swig_cast_info _swigc__p__LayerCompositer[] = { {&_swigt__p__LayerCompositer, 0, 0, 0},{0, 0, 0, 0}};
49273 : static swig_cast_info _swigc__p_cgiRequestObj[] = { {&_swigt__p_cgiRequestObj, 0, 0, 0},{0, 0, 0, 0}};
49274 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
49275 : static swig_cast_info _swigc__p_classObj[] = { {&_swigt__p_classObj, 0, 0, 0},{0, 0, 0, 0}};
49276 : static swig_cast_info _swigc__p_clusterObj[] = { {&_swigt__p_clusterObj, 0, 0, 0},{0, 0, 0, 0}};
49277 : static swig_cast_info _swigc__p_colorObj[] = { {&_swigt__p_colorObj, 0, 0, 0},{0, 0, 0, 0}};
49278 : static swig_cast_info _swigc__p_debugLevel[] = { {&_swigt__p_debugLevel, 0, 0, 0},{0, 0, 0, 0}};
49279 : static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}};
49280 : static swig_cast_info _swigc__p_errorObj[] = { {&_swigt__p_errorObj, 0, 0, 0},{0, 0, 0, 0}};
49281 : static swig_cast_info _swigc__p_expressionObj[] = { {&_swigt__p_expressionObj, 0, 0, 0},{0, 0, 0, 0}};
49282 : static swig_cast_info _swigc__p_fontSetObj[] = { {&_swigt__p_fontSetObj, 0, 0, 0},{0, 0, 0, 0}};
49283 : static swig_cast_info _swigc__p_hashTableObj[] = { {&_swigt__p_hashTableObj, 0, 0, 0},{0, 0, 0, 0}};
49284 : static swig_cast_info _swigc__p_imageObj[] = { {&_swigt__p_imageObj, 0, 0, 0},{0, 0, 0, 0}};
49285 : static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0}, {&_swigt__p_intarray, _p_intarrayTo_p_int, 0, 0},{0, 0, 0, 0}};
49286 : static swig_cast_info _swigc__p_int32_t[] = { {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}};
49287 : static swig_cast_info _swigc__p_intarray[] = { {&_swigt__p_intarray, 0, 0, 0},{0, 0, 0, 0}};
49288 : static swig_cast_info _swigc__p_labelCacheMemberObj[] = { {&_swigt__p_labelCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
49289 : static swig_cast_info _swigc__p_labelCacheObj[] = { {&_swigt__p_labelCacheObj, 0, 0, 0},{0, 0, 0, 0}};
49290 : static swig_cast_info _swigc__p_labelCacheSlotObj[] = { {&_swigt__p_labelCacheSlotObj, 0, 0, 0},{0, 0, 0, 0}};
49291 : static swig_cast_info _swigc__p_labelLeaderObj[] = { {&_swigt__p_labelLeaderObj, 0, 0, 0},{0, 0, 0, 0}};
49292 : static swig_cast_info _swigc__p_labelObj[] = { {&_swigt__p_labelObj, 0, 0, 0},{0, 0, 0, 0}};
49293 : static swig_cast_info _swigc__p_layerObj[] = { {&_swigt__p_layerObj, 0, 0, 0},{0, 0, 0, 0}};
49294 : static swig_cast_info _swigc__p_legendObj[] = { {&_swigt__p_legendObj, 0, 0, 0},{0, 0, 0, 0}};
49295 : static swig_cast_info _swigc__p_lineObj[] = { {&_swigt__p_lineObj, 0, 0, 0},{0, 0, 0, 0}};
49296 : static swig_cast_info _swigc__p_mapObj[] = { {&_swigt__p_mapObj, 0, 0, 0},{0, 0, 0, 0}};
49297 : static swig_cast_info _swigc__p_markerCacheMemberObj[] = { {&_swigt__p_markerCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
49298 : static swig_cast_info _swigc__p_outputFormatObj[] = { {&_swigt__p_outputFormatObj, 0, 0, 0},{0, 0, 0, 0}};
49299 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
49300 : static swig_cast_info _swigc__p_p_double[] = { {&_swigt__p_p_double, 0, 0, 0},{0, 0, 0, 0}};
49301 : static swig_cast_info _swigc__p_p_labelCacheMemberObj[] = { {&_swigt__p_p_labelCacheMemberObj, 0, 0, 0},{0, 0, 0, 0}};
49302 : static swig_cast_info _swigc__p_p_textSymbolObj[] = { {&_swigt__p_p_textSymbolObj, 0, 0, 0},{0, 0, 0, 0}};
49303 : static swig_cast_info _swigc__p_pointObj[] = { {&_swigt__p_pointObj, 0, 0, 0},{0, 0, 0, 0}};
49304 : static swig_cast_info _swigc__p_projectionContext[] = { {&_swigt__p_projectionContext, 0, 0, 0},{0, 0, 0, 0}};
49305 : static swig_cast_info _swigc__p_projectionObj[] = { {&_swigt__p_projectionObj, 0, 0, 0},{0, 0, 0, 0}};
49306 : static swig_cast_info _swigc__p_queryMapObj[] = { {&_swigt__p_queryMapObj, 0, 0, 0},{0, 0, 0, 0}};
49307 : static swig_cast_info _swigc__p_rectObj[] = { {&_swigt__p_rectObj, 0, 0, 0},{0, 0, 0, 0}};
49308 : static swig_cast_info _swigc__p_referenceMapObj[] = { {&_swigt__p_referenceMapObj, 0, 0, 0},{0, 0, 0, 0}};
49309 : static swig_cast_info _swigc__p_resultCacheObj[] = { {&_swigt__p_resultCacheObj, 0, 0, 0},{0, 0, 0, 0}};
49310 : static swig_cast_info _swigc__p_resultObj[] = { {&_swigt__p_resultObj, 0, 0, 0},{0, 0, 0, 0}};
49311 : static swig_cast_info _swigc__p_scaleTokenEntryObj[] = { {&_swigt__p_scaleTokenEntryObj, 0, 0, 0},{0, 0, 0, 0}};
49312 : static swig_cast_info _swigc__p_scaleTokenObj[] = { {&_swigt__p_scaleTokenObj, 0, 0, 0},{0, 0, 0, 0}};
49313 : static swig_cast_info _swigc__p_scalebarObj[] = { {&_swigt__p_scalebarObj, 0, 0, 0},{0, 0, 0, 0}};
49314 : static swig_cast_info _swigc__p_shapeObj[] = { {&_swigt__p_shapeObj, 0, 0, 0},{0, 0, 0, 0}};
49315 : static swig_cast_info _swigc__p_shapefileObj[] = { {&_swigt__p_shapefileObj, 0, 0, 0},{0, 0, 0, 0}};
49316 : static swig_cast_info _swigc__p_styleObj[] = { {&_swigt__p_styleObj, 0, 0, 0},{0, 0, 0, 0}};
49317 : static swig_cast_info _swigc__p_symbolObj[] = { {&_swigt__p_symbolObj, 0, 0, 0},{0, 0, 0, 0}};
49318 : static swig_cast_info _swigc__p_symbolSetObj[] = { {&_swigt__p_symbolSetObj, 0, 0, 0},{0, 0, 0, 0}};
49319 : static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}};
49320 : static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
49321 : static swig_cast_info _swigc__p_webObj[] = { {&_swigt__p_webObj, 0, 0, 0},{0, 0, 0, 0}};
49322 :
49323 : static swig_cast_info *swig_cast_initial[] = {
49324 : _swigc__p_CompositingOperation,
49325 : _swigc__p_DBFFieldType,
49326 : _swigc__p_DBFInfo,
49327 : _swigc__p__CompositingFilter,
49328 : _swigc__p__LayerCompositer,
49329 : _swigc__p_cgiRequestObj,
49330 : _swigc__p_char,
49331 : _swigc__p_classObj,
49332 : _swigc__p_clusterObj,
49333 : _swigc__p_colorObj,
49334 : _swigc__p_debugLevel,
49335 : _swigc__p_double,
49336 : _swigc__p_errorObj,
49337 : _swigc__p_expressionObj,
49338 : _swigc__p_fontSetObj,
49339 : _swigc__p_hashTableObj,
49340 : _swigc__p_imageObj,
49341 : _swigc__p_int,
49342 : _swigc__p_int32_t,
49343 : _swigc__p_intarray,
49344 : _swigc__p_labelCacheMemberObj,
49345 : _swigc__p_labelCacheObj,
49346 : _swigc__p_labelCacheSlotObj,
49347 : _swigc__p_labelLeaderObj,
49348 : _swigc__p_labelObj,
49349 : _swigc__p_layerObj,
49350 : _swigc__p_legendObj,
49351 : _swigc__p_lineObj,
49352 : _swigc__p_mapObj,
49353 : _swigc__p_markerCacheMemberObj,
49354 : _swigc__p_outputFormatObj,
49355 : _swigc__p_p_char,
49356 : _swigc__p_p_double,
49357 : _swigc__p_p_labelCacheMemberObj,
49358 : _swigc__p_p_textSymbolObj,
49359 : _swigc__p_pointObj,
49360 : _swigc__p_projectionContext,
49361 : _swigc__p_projectionObj,
49362 : _swigc__p_queryMapObj,
49363 : _swigc__p_rectObj,
49364 : _swigc__p_referenceMapObj,
49365 : _swigc__p_resultCacheObj,
49366 : _swigc__p_resultObj,
49367 : _swigc__p_scaleTokenEntryObj,
49368 : _swigc__p_scaleTokenObj,
49369 : _swigc__p_scalebarObj,
49370 : _swigc__p_shapeObj,
49371 : _swigc__p_shapefileObj,
49372 : _swigc__p_styleObj,
49373 : _swigc__p_symbolObj,
49374 : _swigc__p_symbolSetObj,
49375 : _swigc__p_uint32_t,
49376 : _swigc__p_void,
49377 : _swigc__p_webObj,
49378 : };
49379 :
49380 :
49381 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
49382 :
49383 : static swig_const_info swig_const_table[] = {
49384 : {0, 0, 0, 0.0, 0, 0}};
49385 :
49386 : #ifdef __cplusplus
49387 : }
49388 : #endif
49389 : /* -----------------------------------------------------------------------------
49390 : * Type initialization:
49391 : * This problem is tough by the requirement that no dynamic
49392 : * memory is used. Also, since swig_type_info structures store pointers to
49393 : * swig_cast_info structures and swig_cast_info structures store pointers back
49394 : * to swig_type_info structures, we need some lookup code at initialization.
49395 : * The idea is that swig generates all the structures that are needed.
49396 : * The runtime then collects these partially filled structures.
49397 : * The SWIG_InitializeModule function takes these initial arrays out of
49398 : * swig_module, and does all the lookup, filling in the swig_module.types
49399 : * array with the correct data and linking the correct swig_cast_info
49400 : * structures together.
49401 : *
49402 : * The generated swig_type_info structures are assigned statically to an initial
49403 : * array. We just loop through that array, and handle each type individually.
49404 : * First we lookup if this type has been already loaded, and if so, use the
49405 : * loaded structure instead of the generated one. Then we have to fill in the
49406 : * cast linked list. The cast data is initially stored in something like a
49407 : * two-dimensional array. Each row corresponds to a type (there are the same
49408 : * number of rows as there are in the swig_type_initial array). Each entry in
49409 : * a column is one of the swig_cast_info structures for that type.
49410 : * The cast_initial array is actually an array of arrays, because each row has
49411 : * a variable number of columns. So to actually build the cast linked list,
49412 : * we find the array of casts associated with the type, and loop through it
49413 : * adding the casts to the list. The one last trick we need to do is making
49414 : * sure the type pointer in the swig_cast_info struct is correct.
49415 : *
49416 : * First off, we lookup the cast->type name to see if it is already loaded.
49417 : * There are three cases to handle:
49418 : * 1) If the cast->type has already been loaded AND the type we are adding
49419 : * casting info to has not been loaded (it is in this module), THEN we
49420 : * replace the cast->type pointer with the type pointer that has already
49421 : * been loaded.
49422 : * 2) If BOTH types (the one we are adding casting info to, and the
49423 : * cast->type) are loaded, THEN the cast info has already been loaded by
49424 : * the previous module so we just ignore it.
49425 : * 3) Finally, if cast->type has not already been loaded, then we add that
49426 : * swig_cast_info to the linked list (because the cast->type) pointer will
49427 : * be correct.
49428 : * ----------------------------------------------------------------------------- */
49429 :
49430 : #ifdef __cplusplus
49431 : extern "C" {
49432 : #if 0
49433 : } /* c-mode */
49434 : #endif
49435 : #endif
49436 :
49437 : #if 0
49438 : #define SWIGRUNTIME_DEBUG
49439 : #endif
49440 :
49441 :
49442 : SWIGRUNTIME void
49443 1 : SWIG_InitializeModule(void *clientdata) {
49444 : size_t i;
49445 : swig_module_info *module_head, *iter;
49446 : int init;
49447 :
49448 : /* check to see if the circular list has been setup, if not, set it up */
49449 1 : if (swig_module.next==0) {
49450 : /* Initialize the swig_module */
49451 1 : swig_module.type_initial = swig_type_initial;
49452 1 : swig_module.cast_initial = swig_cast_initial;
49453 1 : swig_module.next = &swig_module;
49454 : init = 1;
49455 : } else {
49456 : init = 0;
49457 : }
49458 :
49459 : /* Try and load any already created modules */
49460 1 : module_head = SWIG_GetModule(clientdata);
49461 1 : if (!module_head) {
49462 : /* This is the first module loaded for this interpreter */
49463 : /* so set the swig module into the interpreter */
49464 1 : SWIG_SetModule(clientdata, &swig_module);
49465 : } else {
49466 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
49467 : iter=module_head;
49468 : do {
49469 0 : if (iter==&swig_module) {
49470 : /* Our module is already in the list, so there's nothing more to do. */
49471 : return;
49472 : }
49473 0 : iter=iter->next;
49474 0 : } while (iter!= module_head);
49475 :
49476 : /* otherwise we must add our module into the list */
49477 0 : swig_module.next = module_head->next;
49478 0 : module_head->next = &swig_module;
49479 : }
49480 :
49481 : /* When multiple interpreters are used, a module could have already been initialized in
49482 : a different interpreter, but not yet have a pointer in this interpreter.
49483 : In this case, we do not want to continue adding types... everything should be
49484 : set up already */
49485 1 : if (init == 0) return;
49486 :
49487 : /* Now work on filling in swig_module.types */
49488 : #ifdef SWIGRUNTIME_DEBUG
49489 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
49490 : #endif
49491 1 : for (i = 0; i < swig_module.size; ++i) {
49492 : swig_type_info *type = 0;
49493 : swig_type_info *ret;
49494 : swig_cast_info *cast;
49495 :
49496 : #ifdef SWIGRUNTIME_DEBUG
49497 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
49498 : #endif
49499 :
49500 : /* if there is another module already loaded */
49501 1 : if (swig_module.next != &swig_module) {
49502 0 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
49503 : }
49504 0 : if (type) {
49505 : /* Overwrite clientdata field */
49506 : #ifdef SWIGRUNTIME_DEBUG
49507 : printf("SWIG_InitializeModule: found type %s\n", type->name);
49508 : #endif
49509 0 : if (swig_module.type_initial[i]->clientdata) {
49510 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
49511 : #ifdef SWIGRUNTIME_DEBUG
49512 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
49513 : #endif
49514 : }
49515 : } else {
49516 1 : type = swig_module.type_initial[i];
49517 : }
49518 :
49519 : /* Insert casting types */
49520 1 : cast = swig_module.cast_initial[i];
49521 1 : while (cast->type) {
49522 : /* Don't need to add information already in the list */
49523 : ret = 0;
49524 : #ifdef SWIGRUNTIME_DEBUG
49525 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
49526 : #endif
49527 1 : if (swig_module.next != &swig_module) {
49528 0 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
49529 : #ifdef SWIGRUNTIME_DEBUG
49530 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
49531 : #endif
49532 : }
49533 0 : if (ret) {
49534 0 : if (type == swig_module.type_initial[i]) {
49535 : #ifdef SWIGRUNTIME_DEBUG
49536 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
49537 : #endif
49538 0 : cast->type = ret;
49539 : ret = 0;
49540 : } else {
49541 : /* Check for casting already in the list */
49542 0 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
49543 : #ifdef SWIGRUNTIME_DEBUG
49544 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
49545 : #endif
49546 0 : if (!ocast) ret = 0;
49547 : }
49548 : }
49549 :
49550 1 : if (!ret) {
49551 : #ifdef SWIGRUNTIME_DEBUG
49552 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
49553 : #endif
49554 1 : if (type->cast) {
49555 1 : type->cast->prev = cast;
49556 1 : cast->next = type->cast;
49557 : }
49558 1 : type->cast = cast;
49559 : }
49560 1 : cast++;
49561 : }
49562 : /* Set entry in modules->types array equal to the type */
49563 1 : swig_module.types[i] = type;
49564 : }
49565 1 : swig_module.types[i] = 0;
49566 :
49567 : #ifdef SWIGRUNTIME_DEBUG
49568 : printf("**** SWIG_InitializeModule: Cast List ******\n");
49569 : for (i = 0; i < swig_module.size; ++i) {
49570 : int j = 0;
49571 : swig_cast_info *cast = swig_module.cast_initial[i];
49572 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
49573 : while (cast->type) {
49574 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
49575 : cast++;
49576 : ++j;
49577 : }
49578 : printf("---- Total casts: %d\n",j);
49579 : }
49580 : printf("**** SWIG_InitializeModule: Cast List ******\n");
49581 : #endif
49582 : }
49583 :
49584 : /* This function will propagate the clientdata field of type to
49585 : * any new swig_type_info structures that have been added into the list
49586 : * of equivalent types. It is like calling
49587 : * SWIG_TypeClientData(type, clientdata) a second time.
49588 : */
49589 : SWIGRUNTIME void
49590 : SWIG_PropagateClientData(void) {
49591 : size_t i;
49592 : swig_cast_info *equiv;
49593 : static int init_run = 0;
49594 :
49595 : if (init_run) return;
49596 : init_run = 1;
49597 :
49598 : for (i = 0; i < swig_module.size; i++) {
49599 : if (swig_module.types[i]->clientdata) {
49600 : equiv = swig_module.types[i]->cast;
49601 : while (equiv) {
49602 : if (!equiv->converter) {
49603 : if (equiv->type && !equiv->type->clientdata)
49604 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
49605 : }
49606 : equiv = equiv->next;
49607 : }
49608 : }
49609 : }
49610 : }
49611 :
49612 : #ifdef __cplusplus
49613 : #if 0
49614 : {
49615 : /* c-mode */
49616 : #endif
49617 : }
49618 : #endif
49619 :
49620 :
49621 :
49622 : #ifdef __cplusplus
49623 : extern "C" {
49624 : #endif
49625 :
49626 : /* Python-specific SWIG API */
49627 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
49628 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
49629 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
49630 :
49631 : /* -----------------------------------------------------------------------------
49632 : * global variable support code.
49633 : * ----------------------------------------------------------------------------- */
49634 :
49635 : typedef struct swig_globalvar {
49636 : char *name; /* Name of global variable */
49637 : PyObject *(*get_attr)(void); /* Return the current value */
49638 : int (*set_attr)(PyObject *); /* Set the value */
49639 : struct swig_globalvar *next;
49640 : } swig_globalvar;
49641 :
49642 : typedef struct swig_varlinkobject {
49643 : PyObject_HEAD
49644 : swig_globalvar *vars;
49645 : } swig_varlinkobject;
49646 :
49647 : SWIGINTERN PyObject *
49648 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
49649 : #if PY_VERSION_HEX >= 0x03000000
49650 : return PyUnicode_InternFromString("<Swig global variables>");
49651 : #else
49652 : return PyString_FromString("<Swig global variables>");
49653 : #endif
49654 : }
49655 :
49656 : SWIGINTERN PyObject *
49657 : swig_varlink_str(swig_varlinkobject *v) {
49658 : #if PY_VERSION_HEX >= 0x03000000
49659 : PyObject *str = PyUnicode_InternFromString("(");
49660 : PyObject *tail;
49661 : PyObject *joined;
49662 : swig_globalvar *var;
49663 : for (var = v->vars; var; var=var->next) {
49664 : tail = PyUnicode_FromString(var->name);
49665 : joined = PyUnicode_Concat(str, tail);
49666 : Py_DecRef(str);
49667 : Py_DecRef(tail);
49668 : str = joined;
49669 : if (var->next) {
49670 : tail = PyUnicode_InternFromString(", ");
49671 : joined = PyUnicode_Concat(str, tail);
49672 : Py_DecRef(str);
49673 : Py_DecRef(tail);
49674 : str = joined;
49675 : }
49676 : }
49677 : tail = PyUnicode_InternFromString(")");
49678 : joined = PyUnicode_Concat(str, tail);
49679 : Py_DecRef(str);
49680 : Py_DecRef(tail);
49681 : str = joined;
49682 : #else
49683 : PyObject *str = PyString_FromString("(");
49684 : swig_globalvar *var;
49685 : for (var = v->vars; var; var=var->next) {
49686 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
49687 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
49688 : }
49689 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
49690 : #endif
49691 : return str;
49692 : }
49693 :
49694 : SWIGINTERN int
49695 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
49696 : char *tmp;
49697 : PyObject *str = swig_varlink_str(v);
49698 : fprintf(fp,"Swig global variables ");
49699 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
49700 : SWIG_Python_str_DelForPy3(tmp);
49701 : Py_DECREF(str);
49702 : return 0;
49703 : }
49704 :
49705 : SWIGINTERN void
49706 : swig_varlink_dealloc(swig_varlinkobject *v) {
49707 : swig_globalvar *var = v->vars;
49708 : while (var) {
49709 : swig_globalvar *n = var->next;
49710 : free(var->name);
49711 : free(var);
49712 : var = n;
49713 : }
49714 : }
49715 :
49716 : SWIGINTERN PyObject *
49717 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
49718 : PyObject *res = NULL;
49719 : swig_globalvar *var = v->vars;
49720 : while (var) {
49721 : if (strcmp(var->name,n) == 0) {
49722 : res = (*var->get_attr)();
49723 : break;
49724 : }
49725 : var = var->next;
49726 : }
49727 : if (res == NULL && !PyErr_Occurred()) {
49728 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
49729 : }
49730 : return res;
49731 : }
49732 :
49733 : SWIGINTERN int
49734 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
49735 : int res = 1;
49736 : swig_globalvar *var = v->vars;
49737 : while (var) {
49738 : if (strcmp(var->name,n) == 0) {
49739 : res = (*var->set_attr)(p);
49740 : break;
49741 : }
49742 : var = var->next;
49743 : }
49744 : if (res == 1 && !PyErr_Occurred()) {
49745 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
49746 : }
49747 : return res;
49748 : }
49749 :
49750 : SWIGINTERN PyTypeObject*
49751 : swig_varlink_type(void) {
49752 : static char varlink__doc__[] = "Swig var link object";
49753 : static PyTypeObject varlink_type;
49754 : static int type_init = 0;
49755 : if (!type_init) {
49756 : const PyTypeObject tmp = {
49757 : #if PY_VERSION_HEX >= 0x03000000
49758 : PyVarObject_HEAD_INIT(NULL, 0)
49759 : #else
49760 : PyObject_HEAD_INIT(NULL)
49761 : 0, /* ob_size */
49762 : #endif
49763 : (char *)"swigvarlink", /* tp_name */
49764 : sizeof(swig_varlinkobject), /* tp_basicsize */
49765 : 0, /* tp_itemsize */
49766 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
49767 : (printfunc) swig_varlink_print, /* tp_print */
49768 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
49769 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
49770 : 0, /* tp_compare */
49771 : (reprfunc) swig_varlink_repr, /* tp_repr */
49772 : 0, /* tp_as_number */
49773 : 0, /* tp_as_sequence */
49774 : 0, /* tp_as_mapping */
49775 : 0, /* tp_hash */
49776 : 0, /* tp_call */
49777 : (reprfunc) swig_varlink_str, /* tp_str */
49778 : 0, /* tp_getattro */
49779 : 0, /* tp_setattro */
49780 : 0, /* tp_as_buffer */
49781 : 0, /* tp_flags */
49782 : varlink__doc__, /* tp_doc */
49783 : 0, /* tp_traverse */
49784 : 0, /* tp_clear */
49785 : 0, /* tp_richcompare */
49786 : 0, /* tp_weaklistoffset */
49787 : #if PY_VERSION_HEX >= 0x02020000
49788 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
49789 : #endif
49790 : #if PY_VERSION_HEX >= 0x02030000
49791 : 0, /* tp_del */
49792 : #endif
49793 : #if PY_VERSION_HEX >= 0x02060000
49794 : 0, /* tp_version_tag */
49795 : #endif
49796 : #if PY_VERSION_HEX >= 0x03040000
49797 : 0, /* tp_finalize */
49798 : #endif
49799 : #ifdef COUNT_ALLOCS
49800 : 0, /* tp_allocs */
49801 : 0, /* tp_frees */
49802 : 0, /* tp_maxalloc */
49803 : #if PY_VERSION_HEX >= 0x02050000
49804 : 0, /* tp_prev */
49805 : #endif
49806 : 0 /* tp_next */
49807 : #endif
49808 : };
49809 : varlink_type = tmp;
49810 : type_init = 1;
49811 : #if PY_VERSION_HEX < 0x02020000
49812 : varlink_type.ob_type = &PyType_Type;
49813 : #else
49814 : if (PyType_Ready(&varlink_type) < 0)
49815 : return NULL;
49816 : #endif
49817 : }
49818 : return &varlink_type;
49819 : }
49820 :
49821 : /* Create a variable linking object for use later */
49822 : SWIGINTERN PyObject *
49823 : SWIG_Python_newvarlink(void) {
49824 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
49825 : if (result) {
49826 : result->vars = 0;
49827 : }
49828 : return ((PyObject*) result);
49829 : }
49830 :
49831 : SWIGINTERN void
49832 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
49833 : swig_varlinkobject *v = (swig_varlinkobject *) p;
49834 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
49835 : if (gv) {
49836 : size_t size = strlen(name)+1;
49837 : gv->name = (char *)malloc(size);
49838 : if (gv->name) {
49839 : strncpy(gv->name,name,size);
49840 : gv->get_attr = get_attr;
49841 : gv->set_attr = set_attr;
49842 : gv->next = v->vars;
49843 : }
49844 : }
49845 : v->vars = gv;
49846 : }
49847 :
49848 : SWIGINTERN PyObject *
49849 : SWIG_globals(void) {
49850 : static PyObject *_SWIG_globals = 0;
49851 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
49852 : return _SWIG_globals;
49853 : }
49854 :
49855 : /* -----------------------------------------------------------------------------
49856 : * constants/methods manipulation
49857 : * ----------------------------------------------------------------------------- */
49858 :
49859 : /* Install Constants */
49860 : SWIGINTERN void
49861 1 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
49862 : PyObject *obj = 0;
49863 : size_t i;
49864 1 : for (i = 0; constants[i].type; ++i) {
49865 0 : switch(constants[i].type) {
49866 0 : case SWIG_PY_POINTER:
49867 0 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
49868 0 : break;
49869 0 : case SWIG_PY_BINARY:
49870 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
49871 : break;
49872 : default:
49873 : obj = 0;
49874 : break;
49875 : }
49876 0 : if (obj) {
49877 0 : PyDict_SetItemString(d, constants[i].name, obj);
49878 0 : Py_DECREF(obj);
49879 : }
49880 : }
49881 1 : }
49882 :
49883 : /* -----------------------------------------------------------------------------*/
49884 : /* Fix SwigMethods to carry the callback ptrs when needed */
49885 : /* -----------------------------------------------------------------------------*/
49886 :
49887 : SWIGINTERN void
49888 1 : SWIG_Python_FixMethods(PyMethodDef *methods,
49889 : swig_const_info *const_table,
49890 : swig_type_info **types,
49891 : swig_type_info **types_initial) {
49892 : size_t i;
49893 1 : for (i = 0; methods[i].ml_name; ++i) {
49894 1 : const char *c = methods[i].ml_doc;
49895 1 : if (!c) continue;
49896 1 : c = strstr(c, "swig_ptr: ");
49897 1 : if (c) {
49898 : int j;
49899 : swig_const_info *ci = 0;
49900 0 : const char *name = c + 10;
49901 0 : for (j = 0; const_table[j].type; ++j) {
49902 0 : if (strncmp(const_table[j].name, name,
49903 0 : strlen(const_table[j].name)) == 0) {
49904 : ci = &(const_table[j]);
49905 : break;
49906 : }
49907 : }
49908 0 : if (ci) {
49909 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
49910 0 : if (ptr) {
49911 0 : size_t shift = (ci->ptype) - types;
49912 0 : swig_type_info *ty = types_initial[shift];
49913 0 : size_t ldoc = (c - methods[i].ml_doc);
49914 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
49915 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
49916 0 : if (ndoc) {
49917 : char *buff = ndoc;
49918 : strncpy(buff, methods[i].ml_doc, ldoc);
49919 0 : buff += ldoc;
49920 : strncpy(buff, "swig_ptr: ", 10);
49921 0 : buff += 10;
49922 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
49923 0 : methods[i].ml_doc = ndoc;
49924 : }
49925 : }
49926 : }
49927 : }
49928 : }
49929 1 : }
49930 :
49931 : #ifdef __cplusplus
49932 : }
49933 : #endif
49934 :
49935 : /* -----------------------------------------------------------------------------*
49936 : * Partial Init method
49937 : * -----------------------------------------------------------------------------*/
49938 :
49939 : #ifdef __cplusplus
49940 : extern "C"
49941 : #endif
49942 :
49943 : SWIGEXPORT
49944 : #if PY_VERSION_HEX >= 0x03000000
49945 : PyObject*
49946 : #else
49947 : void
49948 : #endif
49949 1 : SWIG_init(void) {
49950 : PyObject *m, *d, *md;
49951 : #if PY_VERSION_HEX >= 0x03000000
49952 : static struct PyModuleDef SWIG_module = {
49953 : # if PY_VERSION_HEX >= 0x03020000
49954 : PyModuleDef_HEAD_INIT,
49955 : # else
49956 : {
49957 : PyObject_HEAD_INIT(NULL)
49958 : NULL, /* m_init */
49959 : 0, /* m_index */
49960 : NULL, /* m_copy */
49961 : },
49962 : # endif
49963 : (char *) SWIG_name,
49964 : NULL,
49965 : -1,
49966 : SwigMethods,
49967 : NULL,
49968 : NULL,
49969 : NULL,
49970 : NULL
49971 : };
49972 : #endif
49973 :
49974 : #if defined(SWIGPYTHON_BUILTIN)
49975 : static SwigPyClientData SwigPyObject_clientdata = {
49976 : 0, 0, 0, 0, 0, 0, 0
49977 : };
49978 : static PyGetSetDef this_getset_def = {
49979 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
49980 : };
49981 : static SwigPyGetSet thisown_getset_closure = {
49982 : (PyCFunction) SwigPyObject_own,
49983 : (PyCFunction) SwigPyObject_own
49984 : };
49985 : static PyGetSetDef thisown_getset_def = {
49986 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
49987 : };
49988 : PyTypeObject *builtin_pytype;
49989 : int builtin_base_count;
49990 : swig_type_info *builtin_basetype;
49991 : PyObject *tuple;
49992 : PyGetSetDescrObject *static_getset;
49993 : PyTypeObject *metatype;
49994 : PyTypeObject *swigpyobject;
49995 : SwigPyClientData *cd;
49996 : PyObject *public_interface, *public_symbol;
49997 : PyObject *this_descr;
49998 : PyObject *thisown_descr;
49999 : PyObject *self = 0;
50000 : int i;
50001 :
50002 : (void)builtin_pytype;
50003 : (void)builtin_base_count;
50004 : (void)builtin_basetype;
50005 : (void)tuple;
50006 : (void)static_getset;
50007 : (void)self;
50008 :
50009 : /* Metaclass is used to implement static member variables */
50010 : metatype = SwigPyObjectType();
50011 : assert(metatype);
50012 : #endif
50013 :
50014 : /* Fix SwigMethods to carry the callback ptrs when needed */
50015 1 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
50016 :
50017 : #if PY_VERSION_HEX >= 0x03000000
50018 1 : m = PyModule_Create(&SWIG_module);
50019 : #else
50020 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
50021 : #endif
50022 :
50023 1 : md = d = PyModule_GetDict(m);
50024 : (void)md;
50025 :
50026 1 : SWIG_InitializeModule(0);
50027 :
50028 : #ifdef SWIGPYTHON_BUILTIN
50029 : swigpyobject = SwigPyObject_TypeOnce();
50030 :
50031 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
50032 : assert(SwigPyObject_stype);
50033 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
50034 : if (!cd) {
50035 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
50036 : SwigPyObject_clientdata.pytype = swigpyobject;
50037 : } else if (swigpyobject->tp_basicsize != cd->pytype->tp_basicsize) {
50038 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
50039 : # if PY_VERSION_HEX >= 0x03000000
50040 : return NULL;
50041 : # else
50042 : return;
50043 : # endif
50044 : }
50045 :
50046 : /* All objects have a 'this' attribute */
50047 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
50048 : (void)this_descr;
50049 :
50050 : /* All objects have a 'thisown' attribute */
50051 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
50052 : (void)thisown_descr;
50053 :
50054 : public_interface = PyList_New(0);
50055 : public_symbol = 0;
50056 : (void)public_symbol;
50057 :
50058 : PyDict_SetItemString(md, "__all__", public_interface);
50059 : Py_DECREF(public_interface);
50060 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
50061 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
50062 : for (i = 0; swig_const_table[i].name != 0; ++i)
50063 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
50064 : #endif
50065 :
50066 1 : SWIG_InstallConstants(d,swig_const_table);
50067 :
50068 :
50069 :
50070 : /* See bug 1203 for discussion of race condition with GD font cache */
50071 1 : if (msSetup() != MS_SUCCESS)
50072 : {
50073 0 : msSetError(MS_MISCERR, "Failed to set up threads and font cache",
50074 : "msSetup()");
50075 : }
50076 :
50077 1 : Py_AtExit(msCleanup);
50078 :
50079 : /* Define Generic MapServer error */
50080 1 : MSExc_MapServerError=PyErr_NewException("_mapscript.MapServerError",NULL,NULL);
50081 1 : if (MSExc_MapServerError != NULL)
50082 1 : PyDict_SetItemString(d, "MapServerError", MSExc_MapServerError);
50083 :
50084 : /* Define MapServer MS_CHILD error */
50085 1 : MSExc_MapServerChildError = PyErr_NewException("_mapscript.MapServerChildError", NULL, NULL);
50086 1 : if (MSExc_MapServerChildError != NULL)
50087 1 : PyDict_SetItemString(d, "MapServerChildError", MSExc_MapServerChildError);
50088 :
50089 :
50090 1 : SWIG_Python_SetConstant(d, "MS_TRUE",SWIG_From_int((int)(1)));
50091 1 : SWIG_Python_SetConstant(d, "MS_FALSE",SWIG_From_int((int)(0)));
50092 1 : SWIG_Python_SetConstant(d, "MS_UNKNOWN",SWIG_From_int((int)(-1)));
50093 1 : SWIG_Python_SetConstant(d, "MS_ON",SWIG_From_int((int)(1)));
50094 1 : SWIG_Python_SetConstant(d, "MS_OFF",SWIG_From_int((int)(0)));
50095 1 : SWIG_Python_SetConstant(d, "MS_DEFAULT",SWIG_From_int((int)(2)));
50096 1 : SWIG_Python_SetConstant(d, "MS_EMBED",SWIG_From_int((int)(3)));
50097 1 : SWIG_Python_SetConstant(d, "MS_DELETE",SWIG_From_int((int)(4)));
50098 1 : SWIG_Python_SetConstant(d, "MS_YES",SWIG_From_int((int)(1)));
50099 1 : SWIG_Python_SetConstant(d, "MS_NO",SWIG_From_int((int)(0)));
50100 1 : SWIG_Python_SetConstant(d, "MS_LAYER_ALLOCSIZE",SWIG_From_int((int)(64)));
50101 1 : SWIG_Python_SetConstant(d, "MS_CLASS_ALLOCSIZE",SWIG_From_int((int)(8)));
50102 1 : SWIG_Python_SetConstant(d, "MS_STYLE_ALLOCSIZE",SWIG_From_int((int)(4)));
50103 1 : SWIG_Python_SetConstant(d, "MS_LABEL_ALLOCSIZE",SWIG_From_int((int)(2)));
50104 1 : SWIG_Python_SetConstant(d, "MS_MAX_LABEL_PRIORITY",SWIG_From_int((int)(10)));
50105 1 : SWIG_Python_SetConstant(d, "MS_MAX_LABEL_FONTS",SWIG_From_int((int)(5)));
50106 1 : SWIG_Python_SetConstant(d, "MS_DEFAULT_LABEL_PRIORITY",SWIG_From_int((int)(1)));
50107 1 : SWIG_Python_SetConstant(d, "MS_LABEL_FORCE_GROUP",SWIG_From_int((int)(2)));
50108 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_SWF",SWIG_From_int((int)(2)));
50109 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_RAWDATA",SWIG_From_int((int)(3)));
50110 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_IMAGEMAP",SWIG_From_int((int)(5)));
50111 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_TEMPLATE",SWIG_From_int((int)(8)));
50112 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_OGR",SWIG_From_int((int)(16)));
50113 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_PLUGIN",SWIG_From_int((int)(100)));
50114 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_RASTER",SWIG_From_int((int)(101)));
50115 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_PDF",SWIG_From_int((int)(102)));
50116 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_CAIRO_SVG",SWIG_From_int((int)(103)));
50117 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_OGL",SWIG_From_int((int)(104)));
50118 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_AGG",SWIG_From_int((int)(105)));
50119 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_KML",SWIG_From_int((int)(106)));
50120 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_UTFGRID",SWIG_From_int((int)(107)));
50121 1 : SWIG_Python_SetConstant(d, "MS_RENDER_WITH_MVT",SWIG_From_int((int)(108)));
50122 1 : SWIG_Python_SetConstant(d, "MS_FILE_MAP",SWIG_From_int((int)(MS_FILE_MAP)));
50123 1 : SWIG_Python_SetConstant(d, "MS_FILE_SYMBOL",SWIG_From_int((int)(MS_FILE_SYMBOL)));
50124 1 : SWIG_Python_SetConstant(d, "MS_INCHES",SWIG_From_int((int)(MS_INCHES)));
50125 1 : SWIG_Python_SetConstant(d, "MS_FEET",SWIG_From_int((int)(MS_FEET)));
50126 1 : SWIG_Python_SetConstant(d, "MS_MILES",SWIG_From_int((int)(MS_MILES)));
50127 1 : SWIG_Python_SetConstant(d, "MS_METERS",SWIG_From_int((int)(MS_METERS)));
50128 1 : SWIG_Python_SetConstant(d, "MS_KILOMETERS",SWIG_From_int((int)(MS_KILOMETERS)));
50129 1 : SWIG_Python_SetConstant(d, "MS_DD",SWIG_From_int((int)(MS_DD)));
50130 1 : SWIG_Python_SetConstant(d, "MS_PIXELS",SWIG_From_int((int)(MS_PIXELS)));
50131 1 : SWIG_Python_SetConstant(d, "MS_PERCENTAGES",SWIG_From_int((int)(MS_PERCENTAGES)));
50132 1 : SWIG_Python_SetConstant(d, "MS_NAUTICALMILES",SWIG_From_int((int)(MS_NAUTICALMILES)));
50133 1 : SWIG_Python_SetConstant(d, "MS_INHERIT",SWIG_From_int((int)(MS_INHERIT)));
50134 1 : SWIG_Python_SetConstant(d, "MS_SHAPE_POINT",SWIG_From_int((int)(MS_SHAPE_POINT)));
50135 1 : SWIG_Python_SetConstant(d, "MS_SHAPE_LINE",SWIG_From_int((int)(MS_SHAPE_LINE)));
50136 1 : SWIG_Python_SetConstant(d, "MS_SHAPE_POLYGON",SWIG_From_int((int)(MS_SHAPE_POLYGON)));
50137 1 : SWIG_Python_SetConstant(d, "MS_SHAPE_NULL",SWIG_From_int((int)(MS_SHAPE_NULL)));
50138 1 : SWIG_Python_SetConstant(d, "MS_LAYER_POINT",SWIG_From_int((int)(MS_LAYER_POINT)));
50139 1 : SWIG_Python_SetConstant(d, "MS_LAYER_LINE",SWIG_From_int((int)(MS_LAYER_LINE)));
50140 1 : SWIG_Python_SetConstant(d, "MS_LAYER_POLYGON",SWIG_From_int((int)(MS_LAYER_POLYGON)));
50141 1 : SWIG_Python_SetConstant(d, "MS_LAYER_RASTER",SWIG_From_int((int)(MS_LAYER_RASTER)));
50142 1 : SWIG_Python_SetConstant(d, "MS_LAYER_ANNOTATION",SWIG_From_int((int)(MS_LAYER_ANNOTATION)));
50143 1 : SWIG_Python_SetConstant(d, "MS_LAYER_QUERY",SWIG_From_int((int)(MS_LAYER_QUERY)));
50144 1 : SWIG_Python_SetConstant(d, "MS_LAYER_CIRCLE",SWIG_From_int((int)(MS_LAYER_CIRCLE)));
50145 1 : SWIG_Python_SetConstant(d, "MS_LAYER_TILEINDEX",SWIG_From_int((int)(MS_LAYER_TILEINDEX)));
50146 1 : SWIG_Python_SetConstant(d, "MS_LAYER_CHART",SWIG_From_int((int)(MS_LAYER_CHART)));
50147 1 : SWIG_Python_SetConstant(d, "MS_TRUETYPE",SWIG_From_int((int)(MS_TRUETYPE)));
50148 1 : SWIG_Python_SetConstant(d, "MS_BITMAP",SWIG_From_int((int)(MS_BITMAP)));
50149 1 : SWIG_Python_SetConstant(d, "MS_FIRST_MATCHING_CLASS",SWIG_From_int((int)(MS_FIRST_MATCHING_CLASS)));
50150 1 : SWIG_Python_SetConstant(d, "MS_ALL_MATCHING_CLASSES",SWIG_From_int((int)(MS_ALL_MATCHING_CLASSES)));
50151 1 : SWIG_Python_SetConstant(d, "MS_POSITIONS_LENGTH",SWIG_From_int((int)(14)));
50152 1 : SWIG_Python_SetConstant(d, "MS_UL",SWIG_From_int((int)(MS_UL)));
50153 1 : SWIG_Python_SetConstant(d, "MS_LR",SWIG_From_int((int)(MS_LR)));
50154 1 : SWIG_Python_SetConstant(d, "MS_UR",SWIG_From_int((int)(MS_UR)));
50155 1 : SWIG_Python_SetConstant(d, "MS_LL",SWIG_From_int((int)(MS_LL)));
50156 1 : SWIG_Python_SetConstant(d, "MS_CR",SWIG_From_int((int)(MS_CR)));
50157 1 : SWIG_Python_SetConstant(d, "MS_CL",SWIG_From_int((int)(MS_CL)));
50158 1 : SWIG_Python_SetConstant(d, "MS_UC",SWIG_From_int((int)(MS_UC)));
50159 1 : SWIG_Python_SetConstant(d, "MS_LC",SWIG_From_int((int)(MS_LC)));
50160 1 : SWIG_Python_SetConstant(d, "MS_CC",SWIG_From_int((int)(MS_CC)));
50161 1 : SWIG_Python_SetConstant(d, "MS_AUTO",SWIG_From_int((int)(MS_AUTO)));
50162 1 : SWIG_Python_SetConstant(d, "MS_XY",SWIG_From_int((int)(MS_XY)));
50163 1 : SWIG_Python_SetConstant(d, "MS_NONE",SWIG_From_int((int)(MS_NONE)));
50164 1 : SWIG_Python_SetConstant(d, "MS_AUTO2",SWIG_From_int((int)(MS_AUTO2)));
50165 1 : SWIG_Python_SetConstant(d, "MS_FOLLOW",SWIG_From_int((int)(MS_FOLLOW)));
50166 1 : SWIG_Python_SetConstant(d, "MS_TINY",SWIG_From_int((int)(5)));
50167 1 : SWIG_Python_SetConstant(d, "MS_SMALL",SWIG_From_int((int)(7)));
50168 1 : SWIG_Python_SetConstant(d, "MS_MEDIUM",SWIG_From_int((int)(10)));
50169 1 : SWIG_Python_SetConstant(d, "MS_LARGE",SWIG_From_int((int)(13)));
50170 1 : SWIG_Python_SetConstant(d, "MS_GIANT",SWIG_From_int((int)(16)));
50171 1 : SWIG_Python_SetConstant(d, "MS_NORMAL",SWIG_From_int((int)(MS_NORMAL)));
50172 1 : SWIG_Python_SetConstant(d, "MS_HILITE",SWIG_From_int((int)(MS_HILITE)));
50173 1 : SWIG_Python_SetConstant(d, "MS_SELECTED",SWIG_From_int((int)(MS_SELECTED)));
50174 1 : SWIG_Python_SetConstant(d, "MS_INLINE",SWIG_From_int((int)(MS_INLINE)));
50175 1 : SWIG_Python_SetConstant(d, "MS_SHAPEFILE",SWIG_From_int((int)(MS_SHAPEFILE)));
50176 1 : SWIG_Python_SetConstant(d, "MS_TILED_SHAPEFILE",SWIG_From_int((int)(MS_TILED_SHAPEFILE)));
50177 1 : SWIG_Python_SetConstant(d, "MS_UNUSED_2",SWIG_From_int((int)(MS_UNUSED_2)));
50178 1 : SWIG_Python_SetConstant(d, "MS_OGR",SWIG_From_int((int)(MS_OGR)));
50179 1 : SWIG_Python_SetConstant(d, "MS_UNUSED_1",SWIG_From_int((int)(MS_UNUSED_1)));
50180 1 : SWIG_Python_SetConstant(d, "MS_POSTGIS",SWIG_From_int((int)(MS_POSTGIS)));
50181 1 : SWIG_Python_SetConstant(d, "MS_WMS",SWIG_From_int((int)(MS_WMS)));
50182 1 : SWIG_Python_SetConstant(d, "MS_ORACLESPATIAL",SWIG_From_int((int)(MS_ORACLESPATIAL)));
50183 1 : SWIG_Python_SetConstant(d, "MS_WFS",SWIG_From_int((int)(MS_WFS)));
50184 1 : SWIG_Python_SetConstant(d, "MS_GRATICULE",SWIG_From_int((int)(MS_GRATICULE)));
50185 1 : SWIG_Python_SetConstant(d, "MS_MYSQL",SWIG_From_int((int)(MS_MYSQL)));
50186 1 : SWIG_Python_SetConstant(d, "MS_RASTER",SWIG_From_int((int)(MS_RASTER)));
50187 1 : SWIG_Python_SetConstant(d, "MS_PLUGIN",SWIG_From_int((int)(MS_PLUGIN)));
50188 1 : SWIG_Python_SetConstant(d, "MS_UNION",SWIG_From_int((int)(MS_UNION)));
50189 1 : SWIG_Python_SetConstant(d, "MS_UVRASTER",SWIG_From_int((int)(MS_UVRASTER)));
50190 1 : SWIG_Python_SetConstant(d, "MS_CONTOUR",SWIG_From_int((int)(MS_CONTOUR)));
50191 1 : SWIG_Python_SetConstant(d, "MS_KERNELDENSITY",SWIG_From_int((int)(MS_KERNELDENSITY)));
50192 1 : SWIG_Python_SetConstant(d, "MS_DB_XBASE",SWIG_From_int((int)(MS_DB_XBASE)));
50193 1 : SWIG_Python_SetConstant(d, "MS_DB_CSV",SWIG_From_int((int)(MS_DB_CSV)));
50194 1 : SWIG_Python_SetConstant(d, "MS_DB_MYSQL",SWIG_From_int((int)(MS_DB_MYSQL)));
50195 1 : SWIG_Python_SetConstant(d, "MS_DB_ORACLE",SWIG_From_int((int)(MS_DB_ORACLE)));
50196 1 : SWIG_Python_SetConstant(d, "MS_DB_POSTGRES",SWIG_From_int((int)(MS_DB_POSTGRES)));
50197 1 : SWIG_Python_SetConstant(d, "MS_JOIN_ONE_TO_ONE",SWIG_From_int((int)(MS_JOIN_ONE_TO_ONE)));
50198 1 : SWIG_Python_SetConstant(d, "MS_JOIN_ONE_TO_MANY",SWIG_From_int((int)(MS_JOIN_ONE_TO_MANY)));
50199 1 : SWIG_Python_SetConstant(d, "MS_SINGLE",SWIG_From_int((int)(0)));
50200 1 : SWIG_Python_SetConstant(d, "MS_MULTIPLE",SWIG_From_int((int)(1)));
50201 1 : SWIG_Python_SetConstant(d, "MS_QUERY_SINGLE",SWIG_From_int((int)(MS_QUERY_SINGLE)));
50202 1 : SWIG_Python_SetConstant(d, "MS_QUERY_MULTIPLE",SWIG_From_int((int)(MS_QUERY_MULTIPLE)));
50203 1 : SWIG_Python_SetConstant(d, "MS_QUERY_IS_NULL",SWIG_From_int((int)(MS_QUERY_IS_NULL)));
50204 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_POINT",SWIG_From_int((int)(MS_QUERY_BY_POINT)));
50205 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_RECT",SWIG_From_int((int)(MS_QUERY_BY_RECT)));
50206 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_SHAPE",SWIG_From_int((int)(MS_QUERY_BY_SHAPE)));
50207 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_ATTRIBUTE",SWIG_From_int((int)(MS_QUERY_BY_ATTRIBUTE)));
50208 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_INDEX",SWIG_From_int((int)(MS_QUERY_BY_INDEX)));
50209 1 : SWIG_Python_SetConstant(d, "MS_QUERY_BY_FILTER",SWIG_From_int((int)(MS_QUERY_BY_FILTER)));
50210 1 : SWIG_Python_SetConstant(d, "MS_ALIGN_DEFAULT",SWIG_From_int((int)(MS_ALIGN_DEFAULT)));
50211 1 : SWIG_Python_SetConstant(d, "MS_ALIGN_LEFT",SWIG_From_int((int)(MS_ALIGN_LEFT)));
50212 1 : SWIG_Python_SetConstant(d, "MS_ALIGN_CENTER",SWIG_From_int((int)(MS_ALIGN_CENTER)));
50213 1 : SWIG_Python_SetConstant(d, "MS_ALIGN_RIGHT",SWIG_From_int((int)(MS_ALIGN_RIGHT)));
50214 1 : SWIG_Python_SetConstant(d, "MS_CJC_NONE",SWIG_From_int((int)(MS_CJC_NONE)));
50215 1 : SWIG_Python_SetConstant(d, "MS_CJC_BEVEL",SWIG_From_int((int)(MS_CJC_BEVEL)));
50216 1 : SWIG_Python_SetConstant(d, "MS_CJC_BUTT",SWIG_From_int((int)(MS_CJC_BUTT)));
50217 1 : SWIG_Python_SetConstant(d, "MS_CJC_MITER",SWIG_From_int((int)(MS_CJC_MITER)));
50218 1 : SWIG_Python_SetConstant(d, "MS_CJC_ROUND",SWIG_From_int((int)(MS_CJC_ROUND)));
50219 1 : SWIG_Python_SetConstant(d, "MS_CJC_SQUARE",SWIG_From_int((int)(MS_CJC_SQUARE)));
50220 1 : SWIG_Python_SetConstant(d, "MS_CJC_TRIANGLE",SWIG_From_int((int)(MS_CJC_TRIANGLE)));
50221 1 : SWIG_Python_SetConstant(d, "MS_CJC_DEFAULT_JOIN_MAXSIZE",SWIG_From_int((int)(3)));
50222 1 : SWIG_Python_SetConstant(d, "MS_SUCCESS",SWIG_From_int((int)(MS_SUCCESS)));
50223 1 : SWIG_Python_SetConstant(d, "MS_FAILURE",SWIG_From_int((int)(MS_FAILURE)));
50224 1 : SWIG_Python_SetConstant(d, "MS_DONE",SWIG_From_int((int)(MS_DONE)));
50225 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_PC256",SWIG_From_int((int)(MS_IMAGEMODE_PC256)));
50226 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_RGB",SWIG_From_int((int)(MS_IMAGEMODE_RGB)));
50227 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_RGBA",SWIG_From_int((int)(MS_IMAGEMODE_RGBA)));
50228 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_INT16",SWIG_From_int((int)(MS_IMAGEMODE_INT16)));
50229 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_FLOAT32",SWIG_From_int((int)(MS_IMAGEMODE_FLOAT32)));
50230 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_BYTE",SWIG_From_int((int)(MS_IMAGEMODE_BYTE)));
50231 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_FEATURE",SWIG_From_int((int)(MS_IMAGEMODE_FEATURE)));
50232 1 : SWIG_Python_SetConstant(d, "MS_IMAGEMODE_NULL",SWIG_From_int((int)(MS_IMAGEMODE_NULL)));
50233 1 : SWIG_Python_SetConstant(d, "MS_GEOS_EQUALS",SWIG_From_int((int)(MS_GEOS_EQUALS)));
50234 1 : SWIG_Python_SetConstant(d, "MS_GEOS_DISJOINT",SWIG_From_int((int)(MS_GEOS_DISJOINT)));
50235 1 : SWIG_Python_SetConstant(d, "MS_GEOS_TOUCHES",SWIG_From_int((int)(MS_GEOS_TOUCHES)));
50236 1 : SWIG_Python_SetConstant(d, "MS_GEOS_OVERLAPS",SWIG_From_int((int)(MS_GEOS_OVERLAPS)));
50237 1 : SWIG_Python_SetConstant(d, "MS_GEOS_CROSSES",SWIG_From_int((int)(MS_GEOS_CROSSES)));
50238 1 : SWIG_Python_SetConstant(d, "MS_GEOS_INTERSECTS",SWIG_From_int((int)(MS_GEOS_INTERSECTS)));
50239 1 : SWIG_Python_SetConstant(d, "MS_GEOS_WITHIN",SWIG_From_int((int)(MS_GEOS_WITHIN)));
50240 1 : SWIG_Python_SetConstant(d, "MS_GEOS_CONTAINS",SWIG_From_int((int)(MS_GEOS_CONTAINS)));
50241 1 : SWIG_Python_SetConstant(d, "MS_GEOS_BEYOND",SWIG_From_int((int)(MS_GEOS_BEYOND)));
50242 1 : SWIG_Python_SetConstant(d, "MS_GEOS_DWITHIN",SWIG_From_int((int)(MS_GEOS_DWITHIN)));
50243 1 : SWIG_Python_SetConstant(d, "MS_TRANSFORM_NONE",SWIG_From_int((int)(MS_TRANSFORM_NONE)));
50244 1 : SWIG_Python_SetConstant(d, "MS_TRANSFORM_ROUND",SWIG_From_int((int)(MS_TRANSFORM_ROUND)));
50245 1 : SWIG_Python_SetConstant(d, "MS_TRANSFORM_SNAPTOGRID",SWIG_From_int((int)(MS_TRANSFORM_SNAPTOGRID)));
50246 1 : SWIG_Python_SetConstant(d, "MS_TRANSFORM_FULLRESOLUTION",SWIG_From_int((int)(MS_TRANSFORM_FULLRESOLUTION)));
50247 1 : SWIG_Python_SetConstant(d, "MS_TRANSFORM_SIMPLIFY",SWIG_From_int((int)(MS_TRANSFORM_SIMPLIFY)));
50248 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_CLEAR",SWIG_From_int((int)(MS_COMPOP_CLEAR)));
50249 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SRC",SWIG_From_int((int)(MS_COMPOP_SRC)));
50250 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DST",SWIG_From_int((int)(MS_COMPOP_DST)));
50251 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_OVER",SWIG_From_int((int)(MS_COMPOP_SRC_OVER)));
50252 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DST_OVER",SWIG_From_int((int)(MS_COMPOP_DST_OVER)));
50253 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_IN",SWIG_From_int((int)(MS_COMPOP_SRC_IN)));
50254 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DST_IN",SWIG_From_int((int)(MS_COMPOP_DST_IN)));
50255 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_OUT",SWIG_From_int((int)(MS_COMPOP_SRC_OUT)));
50256 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DST_OUT",SWIG_From_int((int)(MS_COMPOP_DST_OUT)));
50257 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SRC_ATOP",SWIG_From_int((int)(MS_COMPOP_SRC_ATOP)));
50258 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DST_ATOP",SWIG_From_int((int)(MS_COMPOP_DST_ATOP)));
50259 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_XOR",SWIG_From_int((int)(MS_COMPOP_XOR)));
50260 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_PLUS",SWIG_From_int((int)(MS_COMPOP_PLUS)));
50261 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_MINUS",SWIG_From_int((int)(MS_COMPOP_MINUS)));
50262 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_MULTIPLY",SWIG_From_int((int)(MS_COMPOP_MULTIPLY)));
50263 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SCREEN",SWIG_From_int((int)(MS_COMPOP_SCREEN)));
50264 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_OVERLAY",SWIG_From_int((int)(MS_COMPOP_OVERLAY)));
50265 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DARKEN",SWIG_From_int((int)(MS_COMPOP_DARKEN)));
50266 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_LIGHTEN",SWIG_From_int((int)(MS_COMPOP_LIGHTEN)));
50267 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_COLOR_DODGE",SWIG_From_int((int)(MS_COMPOP_COLOR_DODGE)));
50268 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_COLOR_BURN",SWIG_From_int((int)(MS_COMPOP_COLOR_BURN)));
50269 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_HARD_LIGHT",SWIG_From_int((int)(MS_COMPOP_HARD_LIGHT)));
50270 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_SOFT_LIGHT",SWIG_From_int((int)(MS_COMPOP_SOFT_LIGHT)));
50271 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_DIFFERENCE",SWIG_From_int((int)(MS_COMPOP_DIFFERENCE)));
50272 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_EXCLUSION",SWIG_From_int((int)(MS_COMPOP_EXCLUSION)));
50273 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_CONTRAST",SWIG_From_int((int)(MS_COMPOP_CONTRAST)));
50274 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_INVERT",SWIG_From_int((int)(MS_COMPOP_INVERT)));
50275 1 : SWIG_Python_SetConstant(d, "MS_COMPOP_INVERT_RGB",SWIG_From_int((int)(MS_COMPOP_INVERT_RGB)));
50276 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_LENGTH",SWIG_From_int((int)(12)));
50277 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_SIZE",SWIG_From_int((int)(MS_STYLE_BINDING_SIZE)));
50278 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_WIDTH",SWIG_From_int((int)(MS_STYLE_BINDING_WIDTH)));
50279 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_ANGLE",SWIG_From_int((int)(MS_STYLE_BINDING_ANGLE)));
50280 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_COLOR",SWIG_From_int((int)(MS_STYLE_BINDING_COLOR)));
50281 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OUTLINECOLOR",SWIG_From_int((int)(MS_STYLE_BINDING_OUTLINECOLOR)));
50282 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_SYMBOL",SWIG_From_int((int)(MS_STYLE_BINDING_SYMBOL)));
50283 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OUTLINEWIDTH",SWIG_From_int((int)(MS_STYLE_BINDING_OUTLINEWIDTH)));
50284 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OPACITY",SWIG_From_int((int)(MS_STYLE_BINDING_OPACITY)));
50285 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OFFSET_X",SWIG_From_int((int)(MS_STYLE_BINDING_OFFSET_X)));
50286 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_OFFSET_Y",SWIG_From_int((int)(MS_STYLE_BINDING_OFFSET_Y)));
50287 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_POLAROFFSET_PIXEL",SWIG_From_int((int)(MS_STYLE_BINDING_POLAROFFSET_PIXEL)));
50288 1 : SWIG_Python_SetConstant(d, "MS_STYLE_BINDING_POLAROFFSET_ANGLE",SWIG_From_int((int)(MS_STYLE_BINDING_POLAROFFSET_ANGLE)));
50289 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_LENGTH",SWIG_From_int((int)(12)));
50290 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SIZE",SWIG_From_int((int)(MS_LABEL_BINDING_SIZE)));
50291 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_ANGLE",SWIG_From_int((int)(MS_LABEL_BINDING_ANGLE)));
50292 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_COLOR",SWIG_From_int((int)(MS_LABEL_BINDING_COLOR)));
50293 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OUTLINECOLOR",SWIG_From_int((int)(MS_LABEL_BINDING_OUTLINECOLOR)));
50294 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_FONT",SWIG_From_int((int)(MS_LABEL_BINDING_FONT)));
50295 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_PRIORITY",SWIG_From_int((int)(MS_LABEL_BINDING_PRIORITY)));
50296 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_POSITION",SWIG_From_int((int)(MS_LABEL_BINDING_POSITION)));
50297 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SHADOWSIZEX",SWIG_From_int((int)(MS_LABEL_BINDING_SHADOWSIZEX)));
50298 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_SHADOWSIZEY",SWIG_From_int((int)(MS_LABEL_BINDING_SHADOWSIZEY)));
50299 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OFFSET_X",SWIG_From_int((int)(MS_LABEL_BINDING_OFFSET_X)));
50300 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_OFFSET_Y",SWIG_From_int((int)(MS_LABEL_BINDING_OFFSET_Y)));
50301 1 : SWIG_Python_SetConstant(d, "MS_LABEL_BINDING_ALIGN",SWIG_From_int((int)(MS_LABEL_BINDING_ALIGN)));
50302 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_AND",SWIG_From_int((int)(MS_TOKEN_LOGICAL_AND)));
50303 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_OR",SWIG_From_int((int)(MS_TOKEN_LOGICAL_OR)));
50304 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LOGICAL_NOT",SWIG_From_int((int)(MS_TOKEN_LOGICAL_NOT)));
50305 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_NUMBER",SWIG_From_int((int)(MS_TOKEN_LITERAL_NUMBER)));
50306 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_STRING",SWIG_From_int((int)(MS_TOKEN_LITERAL_STRING)));
50307 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_TIME",SWIG_From_int((int)(MS_TOKEN_LITERAL_TIME)));
50308 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_SHAPE",SWIG_From_int((int)(MS_TOKEN_LITERAL_SHAPE)));
50309 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_LITERAL_BOOLEAN",SWIG_From_int((int)(MS_TOKEN_LITERAL_BOOLEAN)));
50310 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_EQ",SWIG_From_int((int)(MS_TOKEN_COMPARISON_EQ)));
50311 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_NE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_NE)));
50312 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_GT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_GT)));
50313 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LT)));
50314 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LE)));
50315 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_GE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_GE)));
50316 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IEQ",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IEQ)));
50317 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_RE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_RE)));
50318 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IRE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IRE)));
50319 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_IN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_IN)));
50320 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_LIKE",SWIG_From_int((int)(MS_TOKEN_COMPARISON_LIKE)));
50321 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_INTERSECTS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_INTERSECTS)));
50322 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_DISJOINT",SWIG_From_int((int)(MS_TOKEN_COMPARISON_DISJOINT)));
50323 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_TOUCHES",SWIG_From_int((int)(MS_TOKEN_COMPARISON_TOUCHES)));
50324 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_OVERLAPS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_OVERLAPS)));
50325 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_CROSSES",SWIG_From_int((int)(MS_TOKEN_COMPARISON_CROSSES)));
50326 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_WITHIN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_WITHIN)));
50327 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_CONTAINS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_CONTAINS)));
50328 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_EQUALS",SWIG_From_int((int)(MS_TOKEN_COMPARISON_EQUALS)));
50329 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_BEYOND",SWIG_From_int((int)(MS_TOKEN_COMPARISON_BEYOND)));
50330 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_COMPARISON_DWITHIN",SWIG_From_int((int)(MS_TOKEN_COMPARISON_DWITHIN)));
50331 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_LENGTH",SWIG_From_int((int)(MS_TOKEN_FUNCTION_LENGTH)));
50332 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_TOSTRING",SWIG_From_int((int)(MS_TOKEN_FUNCTION_TOSTRING)));
50333 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_COMMIFY",SWIG_From_int((int)(MS_TOKEN_FUNCTION_COMMIFY)));
50334 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_AREA",SWIG_From_int((int)(MS_TOKEN_FUNCTION_AREA)));
50335 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_ROUND",SWIG_From_int((int)(MS_TOKEN_FUNCTION_ROUND)));
50336 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_FROMTEXT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_FROMTEXT)));
50337 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_BUFFER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_BUFFER)));
50338 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_DIFFERENCE",SWIG_From_int((int)(MS_TOKEN_FUNCTION_DIFFERENCE)));
50339 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SIMPLIFY",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SIMPLIFY)));
50340 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SIMPLIFYPT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SIMPLIFYPT)));
50341 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_GENERALIZE",SWIG_From_int((int)(MS_TOKEN_FUNCTION_GENERALIZE)));
50342 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_SMOOTHSIA",SWIG_From_int((int)(MS_TOKEN_FUNCTION_SMOOTHSIA)));
50343 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_JAVASCRIPT",SWIG_From_int((int)(MS_TOKEN_FUNCTION_JAVASCRIPT)));
50344 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_UPPER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_UPPER)));
50345 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_LOWER",SWIG_From_int((int)(MS_TOKEN_FUNCTION_LOWER)));
50346 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_INITCAP",SWIG_From_int((int)(MS_TOKEN_FUNCTION_INITCAP)));
50347 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_FUNCTION_FIRSTCAP",SWIG_From_int((int)(MS_TOKEN_FUNCTION_FIRSTCAP)));
50348 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_DOUBLE",SWIG_From_int((int)(MS_TOKEN_BINDING_DOUBLE)));
50349 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_INTEGER",SWIG_From_int((int)(MS_TOKEN_BINDING_INTEGER)));
50350 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_STRING",SWIG_From_int((int)(MS_TOKEN_BINDING_STRING)));
50351 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_TIME",SWIG_From_int((int)(MS_TOKEN_BINDING_TIME)));
50352 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_SHAPE",SWIG_From_int((int)(MS_TOKEN_BINDING_SHAPE)));
50353 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_MAP_CELLSIZE",SWIG_From_int((int)(MS_TOKEN_BINDING_MAP_CELLSIZE)));
50354 1 : SWIG_Python_SetConstant(d, "MS_TOKEN_BINDING_DATA_CELLSIZE",SWIG_From_int((int)(MS_TOKEN_BINDING_DATA_CELLSIZE)));
50355 1 : SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_BOOLEAN",SWIG_From_int((int)(MS_PARSE_TYPE_BOOLEAN)));
50356 1 : SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_STRING",SWIG_From_int((int)(MS_PARSE_TYPE_STRING)));
50357 1 : SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_SHAPE",SWIG_From_int((int)(MS_PARSE_TYPE_SHAPE)));
50358 1 : SWIG_Python_SetConstant(d, "MS_PARSE_TYPE_SLD",SWIG_From_int((int)(MS_PARSE_TYPE_SLD)));
50359 1 : SWIG_Python_SetConstant(d, "MS_NOOVERRIDE",SWIG_From_int((int)(-1111)));
50360 1 : SWIG_Python_SetConstant(d, "MS_STYLE_SINGLE_SIDED_OFFSET",SWIG_From_int((int)(-99)));
50361 1 : SWIG_Python_SetConstant(d, "MS_STYLE_DOUBLE_SIDED_OFFSET",SWIG_From_int((int)(-999)));
50362 1 : SWIG_Python_SetConstant(d, "MS_LABEL_PERPENDICULAR_OFFSET",SWIG_From_int((int)(-99)));
50363 1 : SWIG_Python_SetConstant(d, "MS_LABEL_PERPENDICULAR_TOP_OFFSET",SWIG_From_int((int)(99)));
50364 1 : SWIG_Python_SetConstant(d, "MS_VERSION_MAJOR",SWIG_From_int((int)(7)));
50365 1 : SWIG_Python_SetConstant(d, "MS_VERSION_MINOR",SWIG_From_int((int)(7)));
50366 1 : SWIG_Python_SetConstant(d, "MS_VERSION_REV",SWIG_From_int((int)(0)));
50367 1 : SWIG_Python_SetConstant(d, "MS_VERSION",SWIG_FromCharPtr("7.7-dev"));
50368 1 : SWIG_Python_SetConstant(d, "MS_VERSION_NUM",SWIG_From_int((int)(70700)));
50369 1 : SWIG_Python_SetConstant(d, "MS_NOERR",SWIG_From_int((int)(0)));
50370 1 : SWIG_Python_SetConstant(d, "MS_IOERR",SWIG_From_int((int)(1)));
50371 1 : SWIG_Python_SetConstant(d, "MS_MEMERR",SWIG_From_int((int)(2)));
50372 1 : SWIG_Python_SetConstant(d, "MS_TYPEERR",SWIG_From_int((int)(3)));
50373 1 : SWIG_Python_SetConstant(d, "MS_SYMERR",SWIG_From_int((int)(4)));
50374 1 : SWIG_Python_SetConstant(d, "MS_REGEXERR",SWIG_From_int((int)(5)));
50375 1 : SWIG_Python_SetConstant(d, "MS_TTFERR",SWIG_From_int((int)(6)));
50376 1 : SWIG_Python_SetConstant(d, "MS_DBFERR",SWIG_From_int((int)(7)));
50377 1 : SWIG_Python_SetConstant(d, "MS_IDENTERR",SWIG_From_int((int)(9)));
50378 1 : SWIG_Python_SetConstant(d, "MS_EOFERR",SWIG_From_int((int)(10)));
50379 1 : SWIG_Python_SetConstant(d, "MS_PROJERR",SWIG_From_int((int)(11)));
50380 1 : SWIG_Python_SetConstant(d, "MS_MISCERR",SWIG_From_int((int)(12)));
50381 1 : SWIG_Python_SetConstant(d, "MS_CGIERR",SWIG_From_int((int)(13)));
50382 1 : SWIG_Python_SetConstant(d, "MS_WEBERR",SWIG_From_int((int)(14)));
50383 1 : SWIG_Python_SetConstant(d, "MS_IMGERR",SWIG_From_int((int)(15)));
50384 1 : SWIG_Python_SetConstant(d, "MS_HASHERR",SWIG_From_int((int)(16)));
50385 1 : SWIG_Python_SetConstant(d, "MS_JOINERR",SWIG_From_int((int)(17)));
50386 1 : SWIG_Python_SetConstant(d, "MS_NOTFOUND",SWIG_From_int((int)(18)));
50387 1 : SWIG_Python_SetConstant(d, "MS_SHPERR",SWIG_From_int((int)(19)));
50388 1 : SWIG_Python_SetConstant(d, "MS_PARSEERR",SWIG_From_int((int)(20)));
50389 1 : SWIG_Python_SetConstant(d, "MS_UNUSEDERR",SWIG_From_int((int)(21)));
50390 1 : SWIG_Python_SetConstant(d, "MS_OGRERR",SWIG_From_int((int)(22)));
50391 1 : SWIG_Python_SetConstant(d, "MS_QUERYERR",SWIG_From_int((int)(23)));
50392 1 : SWIG_Python_SetConstant(d, "MS_WMSERR",SWIG_From_int((int)(24)));
50393 1 : SWIG_Python_SetConstant(d, "MS_WMSCONNERR",SWIG_From_int((int)(25)));
50394 1 : SWIG_Python_SetConstant(d, "MS_ORACLESPATIALERR",SWIG_From_int((int)(26)));
50395 1 : SWIG_Python_SetConstant(d, "MS_WFSERR",SWIG_From_int((int)(27)));
50396 1 : SWIG_Python_SetConstant(d, "MS_WFSCONNERR",SWIG_From_int((int)(28)));
50397 1 : SWIG_Python_SetConstant(d, "MS_MAPCONTEXTERR",SWIG_From_int((int)(29)));
50398 1 : SWIG_Python_SetConstant(d, "MS_HTTPERR",SWIG_From_int((int)(30)));
50399 1 : SWIG_Python_SetConstant(d, "MS_CHILDERR",SWIG_From_int((int)(31)));
50400 1 : SWIG_Python_SetConstant(d, "MS_WCSERR",SWIG_From_int((int)(32)));
50401 1 : SWIG_Python_SetConstant(d, "MS_GEOSERR",SWIG_From_int((int)(33)));
50402 1 : SWIG_Python_SetConstant(d, "MS_RECTERR",SWIG_From_int((int)(34)));
50403 1 : SWIG_Python_SetConstant(d, "MS_TIMEERR",SWIG_From_int((int)(35)));
50404 1 : SWIG_Python_SetConstant(d, "MS_GMLERR",SWIG_From_int((int)(36)));
50405 1 : SWIG_Python_SetConstant(d, "MS_SOSERR",SWIG_From_int((int)(37)));
50406 1 : SWIG_Python_SetConstant(d, "MS_NULLPARENTERR",SWIG_From_int((int)(38)));
50407 1 : SWIG_Python_SetConstant(d, "MS_AGGERR",SWIG_From_int((int)(39)));
50408 1 : SWIG_Python_SetConstant(d, "MS_OWSERR",SWIG_From_int((int)(40)));
50409 1 : SWIG_Python_SetConstant(d, "MS_OGLERR",SWIG_From_int((int)(41)));
50410 1 : SWIG_Python_SetConstant(d, "MS_RENDERERERR",SWIG_From_int((int)(42)));
50411 1 : SWIG_Python_SetConstant(d, "MS_V8ERR",SWIG_From_int((int)(43)));
50412 1 : SWIG_Python_SetConstant(d, "MS_NUMERRORCODES",SWIG_From_int((int)(44)));
50413 1 : SWIG_Python_SetConstant(d, "MESSAGELENGTH",SWIG_From_int((int)(2048)));
50414 1 : SWIG_Python_SetConstant(d, "ROUTINELENGTH",SWIG_From_int((int)(64)));
50415 1 : SWIG_Python_SetConstant(d, "MS_ERROR_LANGUAGE",SWIG_FromCharPtr("en-US"));
50416 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_ERRORSONLY",SWIG_From_int((int)(MS_DEBUGLEVEL_ERRORSONLY)));
50417 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_DEBUG",SWIG_From_int((int)(MS_DEBUGLEVEL_DEBUG)));
50418 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_TUNING",SWIG_From_int((int)(MS_DEBUGLEVEL_TUNING)));
50419 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_V",SWIG_From_int((int)(MS_DEBUGLEVEL_V)));
50420 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_VV",SWIG_From_int((int)(MS_DEBUGLEVEL_VV)));
50421 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_VVV",SWIG_From_int((int)(MS_DEBUGLEVEL_VVV)));
50422 1 : SWIG_Python_SetConstant(d, "MS_DEBUGLEVEL_DEVDEBUG",SWIG_From_int((int)(MS_DEBUGLEVEL_DEVDEBUG)));
50423 1 : SWIG_Python_SetConstant(d, "SHX_BUFFER_PAGE",SWIG_From_int((int)(1024)));
50424 1 : SWIG_Python_SetConstant(d, "MS_SHAPEFILE_POINT",SWIG_From_int((int)(1)));
50425 1 : SWIG_Python_SetConstant(d, "MS_SHAPEFILE_ARC",SWIG_From_int((int)(3)));
50426 1 : SWIG_Python_SetConstant(d, "MS_SHAPEFILE_POLYGON",SWIG_From_int((int)(5)));
50427 1 : SWIG_Python_SetConstant(d, "MS_SHAPEFILE_MULTIPOINT",SWIG_From_int((int)(8)));
50428 1 : SWIG_Python_SetConstant(d, "MS_SHP_POINTZ",SWIG_From_int((int)(11)));
50429 1 : SWIG_Python_SetConstant(d, "MS_SHP_ARCZ",SWIG_From_int((int)(13)));
50430 1 : SWIG_Python_SetConstant(d, "MS_SHP_POLYGONZ",SWIG_From_int((int)(15)));
50431 1 : SWIG_Python_SetConstant(d, "MS_SHP_MULTIPOINTZ",SWIG_From_int((int)(18)));
50432 1 : SWIG_Python_SetConstant(d, "MS_SHP_POINTM",SWIG_From_int((int)(21)));
50433 1 : SWIG_Python_SetConstant(d, "MS_SHP_ARCM",SWIG_From_int((int)(23)));
50434 1 : SWIG_Python_SetConstant(d, "MS_SHP_POLYGONM",SWIG_From_int((int)(25)));
50435 1 : SWIG_Python_SetConstant(d, "MS_SHP_MULTIPOINTM",SWIG_From_int((int)(28)));
50436 1 : SWIG_Python_SetConstant(d, "FTString",SWIG_From_int((int)(FTString)));
50437 1 : SWIG_Python_SetConstant(d, "FTInteger",SWIG_From_int((int)(FTInteger)));
50438 1 : SWIG_Python_SetConstant(d, "FTDouble",SWIG_From_int((int)(FTDouble)));
50439 1 : SWIG_Python_SetConstant(d, "FTInvalid",SWIG_From_int((int)(FTInvalid)));
50440 1 : SWIG_Python_SetConstant(d, "wkp_none",SWIG_From_int((int)(0)));
50441 1 : SWIG_Python_SetConstant(d, "wkp_lonlat",SWIG_From_int((int)(1)));
50442 1 : SWIG_Python_SetConstant(d, "wkp_gmerc",SWIG_From_int((int)(2)));
50443 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_SIMPLE",SWIG_From_int((int)(MS_SYMBOL_SIMPLE)));
50444 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_VECTOR",SWIG_From_int((int)(MS_SYMBOL_VECTOR)));
50445 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_ELLIPSE",SWIG_From_int((int)(MS_SYMBOL_ELLIPSE)));
50446 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_PIXMAP",SWIG_From_int((int)(MS_SYMBOL_PIXMAP)));
50447 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_TRUETYPE",SWIG_From_int((int)(MS_SYMBOL_TRUETYPE)));
50448 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_HATCH",SWIG_From_int((int)(MS_SYMBOL_HATCH)));
50449 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_SVG",SWIG_From_int((int)(MS_SYMBOL_SVG)));
50450 1 : SWIG_Python_SetConstant(d, "MS_SYMBOL_ALLOCSIZE",SWIG_From_int((int)(64)));
50451 1 : SWIG_Python_SetConstant(d, "MS_MAXVECTORPOINTS",SWIG_From_int((int)(100)));
50452 1 : SWIG_Python_SetConstant(d, "MS_MAXPATTERNLENGTH",SWIG_From_int((int)(10)));
50453 1 : SWIG_Python_SetConstant(d, "MS_IMAGECACHESIZE",SWIG_From_int((int)(6)));
50454 1 : SWIG_Python_SetConstant(d, "MS_HASHSIZE",SWIG_From_int((int)(41)));
50455 1 : SWIG_Python_SetConstant(d, "MS_DEFAULT_CGI_PARAMS",SWIG_From_int((int)(100)));
50456 1 : SWIG_Python_SetConstant(d, "MS_GET_REQUEST",SWIG_From_int((int)(MS_GET_REQUEST)));
50457 1 : SWIG_Python_SetConstant(d, "MS_POST_REQUEST",SWIG_From_int((int)(MS_POST_REQUEST)));
50458 : #if PY_VERSION_HEX >= 0x03000000
50459 1 : return m;
50460 : #else
50461 : return;
50462 : #endif
50463 : }
50464 :
|
